| blob | 5bbeb6fbb1ac014201e549bb4f99b14234c22c21 |
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
4 */
6 #include <linux/fs.h>
7 #include <linux/slab.h>
8 #include <linux/highmem.h>
9 #include <linux/pagemap.h>
10 #include <asm/byteorder.h>
11 #include <linux/swap.h>
12 #include <linux/mpage.h>
13 #include <linux/quotaops.h>
14 #include <linux/blkdev.h>
15 #include <linux/uio.h>
16 #include <linux/mm.h>
18 #include <cluster/masklog.h>
42 {
61 }
67 }
76 }
78 /* We don't use the page cache to create symlink data, so if
79 * need be, copy it over from the buffer cache. */
82 iblock;
88 }
90 /* we haven't locked out transactions, so a commit
91 * could've happened. Since we've got a reference on
92 * the bh, even if it commits while we're doing the
93 * copy, the data is still good. */
100 }
106 }
108 }
115 bail:
119 }
123 {
132 }
136 {
151 /* this always does I/O for some reason. */
154 }
162 }
167 /*
168 * ocfs2 never allocates in this function - the only time we
169 * need to use BH_New is when we're extending i_size on a file
170 * system which doesn't support holes, in which case BH_New
171 * allows __block_write_begin() to zero.
172 *
173 * If we see this on a sparse file system, then a truncate has
174 * raced us and removed the cluster. In this case, we clear
175 * the buffers dirty and uptodate bits and let the buffer code
176 * ignore it as a hole.
177 */
182 }
184 /* Treat the unwritten extent as a hole for zeroing purposes. */
198 mlog(ML_ERROR, "Size %llu, clusters %u\n", (unsigned long long)i_size_read(inode), OCFS2_I(inode)->ip_clusters);
201 }
202 }
211 bail:
216 }
220 {
221 loff_t size;
228 }
239 }
245 }
248 {
259 }
262 out:
267 }
270 {
284 }
287 /*
288 * Unlock the folio and cycle ip_alloc_sem so that we don't
289 * busyloop waiting for ip_alloc_sem to unlock
290 */
297 }
299 /*
300 * i_size might have just been updated as we grabbed the meta lock. We
301 * might now be discovering a truncate that hit on another node.
302 * block_read_full_folio->get_block freaks out if it is asked to read
303 * beyond the end of a file, so we check here. Callers
304 * (generic_file_read, vm_ops->fault) are clever enough to check i_size
305 * and notice that the folio they just read isn't needed.
306 *
307 * XXX sys_readahead() seems to get that wrong?
308 */
314 }
318 else
322 out_alloc:
324 out_inode_unlock:
326 out:
330 }
332 /*
333 * This is used only for read-ahead. Failures or difficult to handle
334 * situations are safe to ignore.
335 *
336 * Right now, we don't bother with BH_Boundary - in-inode extent lists
337 * are quite large (243 extents on 4k blocks), so most inodes don't
338 * grow out to a tree. If need be, detecting boundary extents could
339 * trivially be added in a future version of ocfs2_get_block().
340 */
342 {
347 /*
348 * Use the nonblocking flag for the dlm code to avoid page
349 * lock inversion, but don't bother with retrying.
350 */
358 /*
359 * Don't bother with inline-data. There isn't anything
360 * to read-ahead in that case anyway...
361 */
365 /*
366 * Check whether a remote node truncated this file - we just
367 * drop out in that case as it's not worth handling here.
368 */
374 out_up:
376 out_unlock:
378 }
380 /* Note: Because we don't support holes, our allocation has
381 * already happened (allocation writes zeros to the file data)
382 * so we don't have to worry about ordered writes in
383 * ocfs2_writepages.
384 *
385 * ->writepages is called during the process of invalidating the page cache
386 * during blocked lock processing. It can't block on any cluster locks
387 * to during block mapping. It's relying on the fact that the block
388 * mapping can't have disappeared under the dirty pages that it is
389 * being asked to write back.
390 */
393 {
395 }
397 /* Taken from ext3. We don't necessarily need the full blown
398 * functionality yet, but IMHO it's better to cut and paste the whole
399 * thing so we can avoid introducing our own bugs (and easily pick up
400 * their fixes when they happen) --Mark */
408 {
418 {
425 }
429 }
431 }
434 {
435 sector_t status;
443 /*
444 * The swap code (ab-)uses ->bmap to get a block mapping and then
445 * bypasseѕ the file system for actual I/O. We really can't allow
446 * that on refcounted inodes, so we have to skip out here. And yes,
447 * 0 is the magic code for a bmap error..
448 */
452 /* We don't need to lock journal system files, since they aren't
453 * accessed concurrently from multiple nodes.
454 */
461 }
463 }
467 NULL);
472 }
479 }
481 bail:
485 }
488 {
492 }
495 u32 cpos,
498 {
510 }
519 }
521 /*
522 * 'from' and 'to' are the region in the page to avoid zeroing.
523 *
524 * If pagesize > clustersize, this function will avoid zeroing outside
525 * of the cluster boundary.
526 *
527 * from == to == 0 is code for "zero the entire cluster region"
528 */
532 {
547 }
550 }
552 /*
553 * Nonsparse file systems fully allocate before we get to the write
554 * code. This prevents ocfs2_write() from tagging the write as an
555 * allocating one, which means ocfs2_map_folio_blocks() might try to
556 * read-in the blocks at the tail of our file. Avoid reading them by
557 * testing i_size against each block offset.
558 */
561 {
571 }
573 /*
574 * Some of this taken from __block_write_begin(). We already have our
575 * mapping by now though, and the entire write will be allocating or
576 * it won't, so not much need to use BH_New.
577 *
578 * This will also skip zeroing, which is handled externally.
579 */
583 {
599 /*
600 * Ignore blocks outside of our i/o range -
601 * they may belong to unallocated clusters.
602 */
607 }
609 /*
610 * For an allocating write with cluster size >= page
611 * size, we always write the entire page.
612 */
619 }
629 }
632 }
634 /*
635 * If we issued read requests - let them complete.
636 */
641 }
646 /*
647 * If we get -EIO above, zero out any newly allocated blocks
648 * to avoid exposing stale data.
649 */
663 next_bh:
669 }
671 #if (PAGE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
672 #define OCFS2_MAX_CTXT_PAGES 1
673 #else
674 #define OCFS2_MAX_CTXT_PAGES (OCFS2_MAX_CLUSTERSIZE / PAGE_SIZE)
675 #endif
677 #define OCFS2_MAX_CLUSTERS_PER_PAGE (PAGE_SIZE / OCFS2_MIN_CLUSTERSIZE)
682 u32 ue_cpos;
683 u32 ue_phys;
684 };
686 /*
687 * Describe the state of a single cluster to be written to.
688 */
690 u32 c_cpos;
691 u32 c_phys;
692 /*
693 * Give this a unique field because c_phys eventually gets
694 * filled.
695 */
699 };
702 /* Logical cluster position / len of write */
703 u32 w_cpos;
704 u32 w_clen;
706 /* First cluster allocated in a nonsparse extend */
707 u32 w_first_new_cpos;
709 /* Type of caller. Must be one of buffer, mmap, direct. */
710 ocfs2_write_type_t w_type;
714 /*
715 * This is true if page_size > cluster_size.
716 *
717 * It triggers a set of special cases during write which might
718 * have to deal with allocating writes to partial pages.
719 */
722 /*
723 * Folios involved in this write.
724 *
725 * w_target_folio is the folio being written to by the user.
726 *
727 * w_folios is an array of folios which always contains
728 * w_target_folio, and in the case of an allocating write with
729 * page_size < cluster size, it will contain zero'd and mapped
730 * pages adjacent to w_target_folio which need to be written
731 * out in so that future reads from that region will get
732 * zero's.
733 */
738 /*
739 * w_target_locked is used for page_mkwrite path indicating no unlocking
740 * against w_target_folio in ocfs2_write_end_nolock.
741 */
744 /*
745 * ocfs2_write_end() uses this to know what the real range to
746 * write in the target should be.
747 */
751 /*
752 * We could use journal_current_handle() but this is cleaner,
753 * IMHO -Mark
754 */
763 };
766 {
775 }
776 }
779 {
782 /*
783 * w_target_locked is only set to true in the page_mkwrite() case.
784 * The intent is to allow us to lock the target page from write_begin()
785 * to write_end(). The caller must hold a ref on w_target_folio.
786 */
793 }
794 }
797 }
799 }
803 {
813 }
814 }
818 {
823 }
829 {
830 u32 cend;
847 else
856 }
858 /*
859 * If a page has any new buffers, zero them out here, and mark them uptodate
860 * and dirty so they'll be written out (in order to prevent uninitialised
861 * block data from leaking). And clear the new bit.
862 */
864 {
888 }
892 }
893 }
898 }
900 /*
901 * Only called when we have a failure during allocating write to write
902 * zero's to the newly allocated region.
903 */
907 {
924 }
925 }
926 }
931 {
940 /* treat the write as new if the a hole/lseek spanned across
941 * the page boundary.
942 */
953 else
959 }
966 }
968 /*
969 * If we haven't allocated the new folio yet, we
970 * shouldn't be writing it out without copying user
971 * data. This is likely a math error from the caller.
972 */
983 }
984 }
986 /*
987 * Parts of newly allocated folios need to be zero'd.
988 *
989 * Above, we have also rewritten 'to' and 'from' - as far as
990 * the rest of the function is concerned, the entire cluster
991 * range inside of a folio needs to be written.
992 *
993 * We can skip this if the folio is uptodate - it's already
994 * been zero'd from being read in as a hole.
995 */
1002 out:
1004 }
1006 /*
1007 * This function will only grab one clusters worth of pages.
1008 */
1012 {
1016 loff_t last_byte;
1020 /*
1021 * Figure out how many pages we'll be manipulating here. For
1022 * non allocating write, we just change the one
1023 * page. Otherwise, we'll need a whole clusters worth. If we're
1024 * writing past i_size, we only need enough pages to cover the
1025 * last page of the write.
1026 */
1030 /*
1031 * We need the index *past* the last page we could possibly
1032 * touch. This is the page past the end of the write or
1033 * i_size, whichever is greater.
1034 */
1043 }
1051 /*
1052 * ocfs2_pagemkwrite() is a little different
1053 * and wants us to directly use the page
1054 * passed in.
1055 */
1058 /* Exit and let the caller retry */
1064 }
1071 /* Direct write has no mapping page. */
1077 GFP_NOFS);
1082 }
1083 }
1088 }
1089 out:
1093 }
1095 /*
1096 * Prepare a single cluster for write one cluster into the file.
1097 */
1106 {
1108 u64 p_blkno;
1114 u32 tmp_pos;
1116 /*
1117 * This is safe to call with the page locks - it won't take
1118 * any additional semaphores or cluster locks.
1119 */
1125 /*
1126 * This shouldn't happen because we must have already
1127 * calculated the correct meta data allocation required. The
1128 * internal tree allocation code should know how to increase
1129 * transaction credits itself.
1130 *
1131 * If need be, we could handle -EAGAIN for a
1132 * RESTART_TRANS here.
1133 */
1140 }
1150 }
1151 }
1153 /*
1154 * The only reason this should fail is due to an inability to
1155 * find the extent added.
1156 */
1163 }
1174 /* This is the direct io target page. */
1178 }
1182 should_zero);
1187 }
1188 }
1190 /*
1191 * We only have cleanup to do in case of allocating write.
1192 */
1196 out:
1199 }
1206 {
1208 loff_t cluster_off;
1216 /*
1217 * We have to make sure that the total write passed in
1218 * doesn't extend past a single cluster.
1219 */
1234 }
1238 }
1241 out:
1243 }
1245 /*
1246 * ocfs2_write_end() wants to know which parts of the target page it
1247 * should complete the write on. It's easiest to compute them ahead of
1248 * time when a more complete view of the write is available.
1249 */
1253 {
1262 /*
1263 * Allocating write - we may have different boundaries based
1264 * on page size and cluster size.
1265 *
1266 * NOTE: We can no longer compute one value from the other as
1267 * the actual write length and user provided length may be
1268 * different.
1269 */
1272 /*
1273 * We only care about the 1st and last cluster within
1274 * our range and whether they should be zero'd or not. Either
1275 * value may be extended out to the start/end of a
1276 * newly allocated cluster.
1277 */
1283 NULL);
1289 NULL,
1294 }
1295 }
1297 /*
1298 * Check if this extent is marked UNWRITTEN by direct io. If so, we need not to
1299 * do the zero work. And should not to clear UNWRITTEN since it will be cleared
1300 * by the direct io procedure.
1301 * If this is a new extent that allocated by direct io, we should mark it in
1302 * the ip_unwritten_list.
1303 */
1307 {
1315 retry:
1317 /* Needs not to zero no metter buffer or direct. The one who is zero
1318 * the cluster is doing zero. And he will clear unwritten after all
1319 * cluster io finished. */
1326 }
1327 }
1335 GFP_NOFS);
1339 }
1341 }
1342 /* This direct write will doing zero. */
1350 unlock:
1352 out:
1355 }
1357 /*
1358 * Populate each single-cluster write descriptor in the write context
1359 * with information about the i/o to be done.
1360 *
1361 * Returns the number of clusters that will have to be allocated, as
1362 * well as a worst case estimate of the number of extent records that
1363 * would have to be created during a write to an unwritten region.
1364 */
1369 {
1385 /*
1386 * Need to look up the next extent record.
1387 */
1393 }
1395 /* We should already CoW the refcountd extent. */
1398 /*
1399 * Assume worst case - that we're writing in
1400 * the middle of the extent.
1401 *
1402 * We can assume that the write proceeds from
1403 * left to right, in which case the extent
1404 * insert code is smart enough to coalesce the
1405 * next splits into the previous records created.
1406 */
1410 /*
1411 * Only increment phys if it doesn't describe
1412 * a hole.
1413 */
1414 phys++;
1415 }
1417 /*
1418 * If w_first_new_cpos is < UINT_MAX, we have a non-sparse
1419 * file that got extended. w_first_new_cpos tells us
1420 * where the newly allocated clusters are so we can
1421 * zero them.
1422 */
1426 }
1434 }
1439 }
1445 }
1447 num_clusters--;
1448 }
1451 out:
1453 }
1458 {
1470 }
1479 }
1480 /*
1481 * If we don't set w_num_folios then this folio won't get unlocked
1482 * and freed on cleanup of the write context.
1483 */
1489 OCFS2_JOURNAL_ACCESS_WRITE);
1495 }
1506 }
1507 }
1510 out:
1512 }
1515 {
1521 }
1526 {
1536 /*
1537 * Handle inodes which already have inline data 1st.
1538 */
1544 /*
1545 * The write won't fit - we have to give this inode an
1546 * inline extent list now.
1547 */
1552 }
1554 /*
1555 * Check whether the inode can accept inline data.
1556 */
1560 /*
1561 * Check whether the write can fit.
1562 */
1568 do_inline_write:
1573 }
1575 /*
1576 * This signals to the caller that the data can be written
1577 * inline.
1578 */
1580 out:
1582 }
1584 /*
1585 * This function only does anything for file systems which can't
1586 * handle sparse files.
1587 *
1588 * What we want to do here is fill in any hole between the current end
1589 * of allocation and the end of our write. That way the rest of the
1590 * write path can treat it as an non-allocating write, which has no
1591 * special case code for sparse/nonsparse files.
1592 */
1597 {
1610 /* There is no wc if this is call from direct. */
1616 }
1619 loff_t pos)
1620 {
1628 }
1634 {
1647 try_again:
1652 }
1660 }
1664 }
1665 }
1667 /* Direct io change i_size late, should not zero tail here. */
1671 else
1677 }
1678 }
1691 }
1692 }
1699 }
1711 /*
1712 * We set w_target_from, w_target_to here so that
1713 * ocfs2_write_end() knows which range in the target page to
1714 * write out. An allocation requires that we write the entire
1715 * cluster range.
1716 */
1718 /*
1719 * XXX: We are stretching the limits of
1720 * ocfs2_lock_allocators(). It greatly over-estimates
1721 * the work to be done.
1722 */
1731 }
1739 /* direct write needs not to start trans if no extents alloc. */
1742 /*
1743 * We have to zero sparse allocated clusters, unwritten extent clusters,
1744 * and non-sparse clusters we just extended. For non-sparse writes,
1745 * we know zeros will only be needed in the first and/or last cluster.
1746 */
1750 else
1760 }
1769 }
1772 OCFS2_JOURNAL_ACCESS_WRITE);
1776 }
1778 /*
1779 * Fill our folio array first. That way we've grabbed enough so
1780 * that we can zero and flush if we error after adding the
1781 * extent.
1782 */
1786 /*
1787 * ocfs2_grab_folios_for_write() returns -EAGAIN if it
1788 * could not lock the target folio. In this case, we exit
1789 * with no error and no target folio. This will trigger
1790 * the caller, page_mkwrite(), to re-try the operation.
1791 */
1796 }
1800 }
1803 len);
1807 }
1814 success:
1819 out_quota:
1823 out_commit:
1826 out:
1827 /*
1828 * The mmapped page won't be unlocked in ocfs2_free_write_ctxt(),
1829 * even in case of error here like ENOSPC and ENOMEM. So, we need
1830 * to unlock the target page manually to prevent deadlocks when
1831 * retrying again on ENOSPC, or when returning non-VM_FAULT_LOCKED
1832 * to VM code.
1833 */
1842 }
1846 }
1849 /*
1850 * Try to free some truncate log so that we can have enough
1851 * clusters to allocate.
1852 */
1861 }
1864 }
1869 {
1878 }
1880 /*
1881 * Take alloc sem here to prevent concurrent lookups. That way
1882 * the mapping, zeroing and tree manipulation within
1883 * ocfs2_write() will be safe against ->read_folio(). This
1884 * should also serve to lock out allocation from a shared
1885 * writeable region.
1886 */
1894 }
1900 out_fail:
1907 }
1913 {
1918 }
1919 }
1929 }
1933 {
1951 }
1952 }
1957 }
1960 loff_t new_isize;
1970 /*
1971 * When folio is fully beyond new isize (data copy
1972 * failed), do not bother zeroing the folio. Invalidate
1973 * it instead so that writeback does not get confused
1974 * put page & buffer dirty bits into inconsistent
1975 * state.
1976 */
1979 }
1980 }
1987 /* This is the direct io target folio */
1999 /*
2000 * Pages adjacent to the target (if any) imply
2001 * a hole-filling write in which case we want
2002 * to flush their entire range.
2003 */
2006 }
2014 }
2016 }
2017 }
2019 out_write_size:
2020 /* Direct io do not update i_size here. */
2026 }
2034 }
2038 out:
2039 /* unlock pages before dealloc since it needs acquiring j_trans_barrier
2040 * lock, or it will cause a deadlock since journal commit threads holds
2041 * this lock and will ask for the page lock when flushing the data.
2042 * put it here to preserve the unlock order.
2043 */
2055 }
2060 {
2070 }
2076 pid_t dw_writer_pid;
2077 };
2081 {
2098 }
2102 {
2105 }
2107 /*
2108 * TODO: Make this into a generic get_blocks function.
2109 *
2110 * From do_direct_io in direct-io.c:
2111 * "So what we do is to permit the ->get_blocks function to populate
2112 * bh.b_size with the size of IO which is permitted at this offset and
2113 * this i_blkbits."
2114 *
2115 * This function is called directly from get_more_blocks in direct-io.c.
2116 *
2117 * called like this: dio->get_blocks(dio->inode, fs_startblk,
2118 * fs_count, map_bh, dio->rw == WRITE);
2119 */
2122 {
2129 u64 p_blkno;
2139 /*
2140 * bh_result->b_size is count in get_more_blocks according to write
2141 * "pos" and "end", we need map twice to return different buffer state:
2142 * 1. area in file size, not set NEW;
2143 * 2. area out file size, set NEW.
2144 *
2145 * iblock endblk
2146 * |--------|---------|---------|---------
2147 * |<-------area in file------->|
2148 */
2157 /*
2158 * Because we need to change file size in ocfs2_dio_end_io_write(), or
2159 * we may need to add it to orphan dir. So can not fall to fast path
2160 * while file size will be changed.
2161 */
2164 /* This is the fast path for re-write. */
2171 /* Clear state set by ocfs2_get_block. */
2173 }
2180 }
2185 /*
2186 * when we are going to alloc extents beyond file size, add the
2187 * inode to orphan dir, so we can recall those spaces when
2188 * system crashed during write.
2189 */
2194 }
2196 }
2202 }
2209 else
2215 }
2216 }
2224 }
2240 /* May sleep in end_io. It should not happen in a irq context. So defer
2241 * it to dio work queue. */
2249 ue_node);
2251 /* The physical address may be 0, fill it. */
2256 }
2261 unlock:
2265 out:
2267 }
2271 loff_t offset,
2272 ssize_t bytes)
2273 {
2289 /* We do clear unwritten, delete orphan, change i_size here. If neither
2290 * of these happen, we can skip all this. */
2300 }
2304 /* Delete orphan before acquire i_rwsem. */
2314 }
2320 /* Attach dealloc with extent tree in case that we may reuse extents
2321 * which are already unlinked from current extent tree due to extent
2322 * rotation and merging.
2323 */
2331 }
2340 }
2342 OCFS2_JOURNAL_ACCESS_WRITE);
2346 }
2353 }
2361 }
2362 }
2368 }
2369 commit:
2371 unlock:
2375 out:
2384 }
2386 /*
2387 * ocfs2_dio_end_io is called by the dio core when a dio is finished. We're
2388 * particularly interested in the aio/dio case. We use the rw_lock DLM lock
2389 * to protect io on one node from truncation on another.
2390 */
2392 loff_t offset,
2393 ssize_t bytes,
2395 {
2400 /* this io's submitter should not have unlocked this before we could */
2409 bytes);
2410 else
2412 }
2419 }
2422 {
2428 /*
2429 * Fallback to buffered I/O if we see an inode without
2430 * extents.
2431 */
2435 /* Fallback to buffered I/O if we do not support append dio. */
2442 else
2448 }
2464 };