| blob | e5d9908c0bc38393e19b12922e5ffeb2107e6ae8 |
1 /*
2 * linux/fs/ext4/inode.c
3 *
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
8 *
9 * from
10 *
11 * linux/fs/minix/inode.c
12 *
13 * Copyright (C) 1991, 1992 Linus Torvalds
14 *
15 * 64-bit file support on 64-bit platforms by Jakub Jelinek
16 * (jj@sunsite.ms.mff.cuni.cz)
17 *
18 * Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000
19 */
21 #include <linux/fs.h>
22 #include <linux/time.h>
23 #include <linux/jbd2.h>
24 #include <linux/highuid.h>
25 #include <linux/pagemap.h>
26 #include <linux/quotaops.h>
27 #include <linux/string.h>
28 #include <linux/buffer_head.h>
29 #include <linux/writeback.h>
30 #include <linux/pagevec.h>
31 #include <linux/mpage.h>
32 #include <linux/namei.h>
33 #include <linux/uio.h>
34 #include <linux/bio.h>
35 #include <linux/workqueue.h>
36 #include <linux/kernel.h>
37 #include <linux/printk.h>
38 #include <linux/slab.h>
39 #include <linux/ratelimit.h>
40 #include <linux/aio.h>
41 #include <linux/bitops.h>
48 #include <trace/events/ext4.h>
50 #define MPAGE_DA_EXTENT_TAIL 0x01
54 {
56 __u16 csum_lo;
58 __u32 csum;
66 }
77 }
81 {
87 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
95 else
99 }
103 {
104 __u32 csum;
109 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
117 }
120 loff_t new_size)
121 {
123 /*
124 * If jinode is zero, then we never opened the file for
125 * writing, so there's no need to call
126 * jbd2_journal_begin_ordered_truncate() since there's no
127 * outstanding writes we need to flush.
128 */
133 new_size);
134 }
143 /*
144 * Test whether an inode is a fast symlink.
145 */
147 {
152 }
154 /*
155 * Restart the transaction associated with *handle. This does a commit,
156 * so before we call here everything must be consistently dirtied against
157 * this transaction.
158 */
161 {
164 /*
165 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
166 * moment, get_block can be called only for blocks inside i_size since
167 * page cache has been already dropped and writes are blocked by
168 * i_mutex. So we can safely drop the i_data_sem here.
169 */
178 }
180 /*
181 * Called at the last iput() if i_nlink is zero.
182 */
184 {
191 /*
192 * When journalling data dirty buffers are tracked only in the
193 * journal. So although mm thinks everything is clean and
194 * ready for reaping the inode might still have some pages to
195 * write in the running transaction or waiting to be
196 * checkpointed. Thus calling jbd2_journal_invalidatepage()
197 * (via truncate_inode_pages()) to discard these buffers can
198 * cause data loss. Also even if we did not discard these
199 * buffers, we would have no way to find them after the inode
200 * is reaped and thus user could see stale data if he tries to
201 * read them before the transaction is checkpointed. So be
202 * careful and force everything to disk here... We use
203 * ei->i_datasync_tid to store the newest transaction
204 * containing inode's data.
205 *
206 * Note that directories do not have this problem because they
207 * don't use page cache.
208 */
217 }
222 }
235 /*
236 * Protect us against freezing - iput() caller didn't have to have any
237 * protection against it
238 */
244 /*
245 * If we're going to skip the normal cleanup, we still need to
246 * make sure that the in-core orphan linked list is properly
247 * cleaned up.
248 */
252 }
262 }
266 /*
267 * ext4_ext_truncate() doesn't reserve any slop when it
268 * restarts journal transactions; therefore there may not be
269 * enough credits left in the handle to remove the inode from
270 * the orphan list and set the dtime field.
271 */
279 stop_handle:
284 }
285 }
287 /*
288 * Kill off the orphan record which ext4_truncate created.
289 * AKPM: I think this can be inside the above `if'.
290 * Note that ext4_orphan_del() has to be able to cope with the
291 * deletion of a non-existent orphan - this is because we don't
292 * know if ext4_truncate() actually created an orphan record.
293 * (Well, we could do this if we need to, but heck - it works)
294 */
298 /*
299 * One subtle ordering requirement: if anything has gone wrong
300 * (transaction abort, IO errors, whatever), then we can still
301 * do these next steps (the fs will already have been marked as
302 * having errors), but we can't free the inode if the mark_dirty
303 * fails.
304 */
306 /* If that failed, just do the required in-core inode clear. */
308 else
313 no_delete:
315 }
317 #ifdef CONFIG_QUOTA
319 {
321 }
322 #endif
324 /*
325 * Calculate the number of metadata blocks need to reserve
326 * to allocate a block located at @lblock
327 */
329 {
334 }
336 /*
337 * Called with i_data_sem down, which is important since we can call
338 * ext4_discard_preallocations() from here.
339 */
342 {
355 }
359 "with only %d reserved metadata blocks "
366 }
368 /* Update per-inode reservations */
376 /*
377 * We can release all of the reserved metadata blocks
378 * only when we have written all of the delayed
379 * allocation blocks.
380 */
385 }
388 /* Update quota subsystem for data blocks */
392 /*
393 * We did fallocate with an offset that is already delayed
394 * allocated. So on delayed allocated writeback we should
395 * not re-claim the quota for fallocated blocks.
396 */
398 }
400 /*
401 * If we have done all the pending block allocations and if
402 * there aren't any writers on the inode, we can discard the
403 * inode's preallocations.
404 */
408 }
413 {
417 "lblock %lu mapped to illegal pblock "
421 }
423 }
425 #define check_block_validity(inode, map) \
426 __check_block_validity((inode), __func__, __LINE__, (map))
428 #ifdef ES_AGGRESSIVE_TEST
434 {
438 /*
439 * There is a race window that the result is not the same.
440 * e.g. xfstests #223 when dioread_nolock enables. The reason
441 * is that we lookup a block mapping in extent status tree with
442 * out taking i_data_sem. So at the time the unwritten extent
443 * could be converted.
444 */
449 EXT4_GET_BLOCKS_KEEP_SIZE);
452 EXT4_GET_BLOCKS_KEEP_SIZE);
453 }
456 /*
457 * Clear EXT4_MAP_FROM_CLUSTER and EXT4_MAP_BOUNDARY flag
458 * because it shouldn't be marked in es_map->m_flags.
459 */
462 /*
463 * We don't check m_len because extent will be collpased in status
464 * tree. So the m_len might not equal.
465 */
470 "es_cached ex [%d/%d/%llu/%x] != "
476 }
477 }
480 /*
481 * The ext4_map_blocks() function tries to look up the requested blocks,
482 * and returns if the blocks are already mapped.
483 *
484 * Otherwise it takes the write lock of the i_data_sem and allocate blocks
485 * and store the allocated blocks in the result buffer head and mark it
486 * mapped.
487 *
488 * If file type is extents based, it will call ext4_ext_map_blocks(),
489 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
490 * based files
491 *
492 * On success, it returns the number of blocks being mapped or allocate.
493 * if create==0 and the blocks are pre-allocated and uninitialized block,
494 * the result buffer head is unmapped. If the create ==1, it will make sure
495 * the buffer head is mapped.
496 *
497 * It returns 0 if plain look up failed (blocks have not been allocated), in
498 * that case, buffer head is unmapped
499 *
500 * It returns the error in case of allocation failure.
501 */
504 {
507 #ifdef ES_AGGRESSIVE_TEST
511 #endif
518 /* We can handle the block number less than EXT_MAX_BLOCKS */
522 /* Lookup extent status tree firstly */
538 }
539 #ifdef ES_AGGRESSIVE_TEST
542 #endif
544 }
546 /*
547 * Try to see if we can get the block without requesting a new
548 * file system block.
549 */
554 EXT4_GET_BLOCKS_KEEP_SIZE);
557 EXT4_GET_BLOCKS_KEEP_SIZE);
558 }
565 "ES len assertion failed for inode "
569 }
581 }
585 found:
590 }
592 /* If it is only a block(s) look up */
596 /*
597 * Returns if the blocks have already allocated
598 *
599 * Note that if blocks have been preallocated
600 * ext4_ext_get_block() returns the create = 0
601 * with buffer head unmapped.
602 */
606 /*
607 * Here we clear m_flags because after allocating an new extent,
608 * it will be set again.
609 */
612 /*
613 * New blocks allocate and/or writing to uninitialized extent
614 * will possibly result in updating i_data, so we take
615 * the write lock of i_data_sem, and call get_blocks()
616 * with create == 1 flag.
617 */
620 /*
621 * if the caller is from delayed allocation writeout path
622 * we have already reserved fs blocks for allocation
623 * let the underlying get_block() function know to
624 * avoid double accounting
625 */
628 /*
629 * We need to check for EXT4 here because migrate
630 * could have changed the inode type in between
631 */
638 /*
639 * We allocated new blocks which will result in
640 * i_data's format changing. Force the migrate
641 * to fail by clearing migrate flags
642 */
644 }
646 /*
647 * Update reserved blocks/metadata blocks after successful
648 * block allocation which had been deferred till now. We don't
649 * support fallocate for non extent files. So we can update
650 * reserve space here.
651 */
655 }
665 "ES len assertion failed for inode "
669 }
671 /*
672 * If the extent has been zeroed out, we don't need to update
673 * extent status tree.
674 */
679 }
690 }
692 has_zeroout:
698 }
700 }
702 /* Maximum number of blocks we map for direct IO at once. */
703 #define DIO_MAX_BLOCKS 4096
707 {
720 /* Direct IO write... */
725 dio_credits);
729 }
731 }
743 }
747 }
751 {
754 }
756 /*
757 * `handle' can be NULL if create is zero
758 */
761 {
773 /* ensure we send some value back into *errp */
787 }
792 /*
793 * Now that we do not always journal data, we should
794 * keep in mind whether this should always journal the
795 * new buffer as metadata. For now, regular file
796 * writes use ext4_get_block instead, so it's not a
797 * problem.
798 */
805 }
813 }
818 }
820 }
824 {
839 }
848 {
864 }
868 }
870 }
872 /*
873 * To preserve ordering, it is essential that the hole instantiation and
874 * the data write be encapsulated in a single transaction. We cannot
875 * close off a transaction and start a new one between the ext4_get_block()
876 * and the commit_write(). So doing the jbd2_journal_start at the start of
877 * prepare_write() is the right place.
878 *
879 * Also, this function can nest inside ext4_writepage(). In that case, we
880 * *know* that ext4_writepage() has generated enough buffer credits to do the
881 * whole page. So we won't block on the journal in that case, which is good,
882 * because the caller may be PF_MEMALLOC.
883 *
884 * By accident, ext4 can be reentered when a transaction is open via
885 * quota file writes. If we were to commit the transaction while thus
886 * reentered, there can be a deadlock - we would be holding a quota
887 * lock, and the commit would never complete if another thread had a
888 * transaction open and was blocking on the quota lock - a ranking
889 * violation.
890 *
891 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
892 * will _not_ run commit under these circumstances because handle->h_ref
893 * is elevated. We'll still have enough credits for the tiny quotafile
894 * write.
895 */
898 {
904 /*
905 * __block_write_begin() could have dirtied some buffers. Clean
906 * the dirty bit as jbd2_journal_get_write_access() could complain
907 * otherwise about fs integrity issues. Setting of the dirty bit
908 * by __block_write_begin() isn't a real problem here as we clear
909 * the bit before releasing a page lock and thus writeback cannot
910 * ever write the buffer.
911 */
918 }
925 {
931 pgoff_t index;
935 /*
936 * Reserve one block more for addition to orphan list in case
937 * we allocate blocks but write fails for some reason
938 */
951 }
953 /*
954 * grab_cache_page_write_begin() can take a long time if the
955 * system is thrashing due to memory pressure, or if the page
956 * is being written back. So grab it first before we start
957 * the transaction handle. This also allows us to allocate
958 * the page (if needed) without using GFP_NOFS.
959 */
960 retry_grab:
966 retry_journal:
971 }
975 /* The page got truncated from under us */
980 }
981 /* In case writeback began while the page was unlocked */
986 else
992 do_journal_get_write_access);
993 }
997 /*
998 * __block_write_begin may have instantiated a few blocks
999 * outside i_size. Trim these off again. Don't need
1000 * i_size_read because we hold i_mutex.
1001 *
1002 * Add inode to orphan list in case we crash before
1003 * truncate finishes
1004 */
1011 /*
1012 * If truncate failed early the inode might
1013 * still be on the orphan list; we need to
1014 * make sure the inode is removed from the
1015 * orphan list in that case.
1016 */
1019 }
1026 }
1029 }
1031 /* For write_end() in data=journal mode */
1033 {
1042 }
1044 /*
1045 * We need to pick up the new inode size which generic_commit_write gave us
1046 * `file' can be NULL - eg, when called from page_symlink().
1047 *
1048 * ext4 never places buffers on inode->i_mapping->private_list. metadata
1049 * buffers are managed internally.
1050 */
1055 {
1068 }
1069 }
1081 /*
1082 * No need to use i_size_read() here, the i_size
1083 * cannot change under us because we hole i_mutex.
1084 *
1085 * But it's important to update i_size while still holding page lock:
1086 * page writeout could otherwise come in and zero beyond i_size.
1087 */
1091 }
1094 /* We need to mark inode dirty even if
1095 * new_i_size is less that inode->i_size
1096 * but greater than i_disksize. (hint delalloc)
1097 */
1100 }
1104 /*
1105 * Don't mark the inode dirty under page lock. First, it unnecessarily
1106 * makes the holding time of page lock longer. Second, it forces lock
1107 * ordering of page lock and transaction start for journaling
1108 * filesystems.
1109 */
1114 /* if we have allocated more blocks and copied
1115 * less. We will have blocks allocated outside
1116 * inode->i_size. So truncate them
1117 */
1119 errout:
1126 /*
1127 * If truncate failed early the inode might still be
1128 * on the orphan list; we need to make sure the inode
1129 * is removed from the orphan list in that case.
1130 */
1133 }
1136 }
1142 {
1148 loff_t new_i_size;
1164 }
1170 }
1181 }
1186 /* if we have allocated more blocks and copied
1187 * less. We will have blocks allocated outside
1188 * inode->i_size. So truncate them
1189 */
1197 /*
1198 * If truncate failed early the inode might still be
1199 * on the orphan list; we need to make sure the inode
1200 * is removed from the orphan list in that case.
1201 */
1204 }
1207 }
1209 /*
1210 * Reserve a metadata for a single block located at lblock
1211 */
1213 {
1217 ext4_lblk_t save_last_lblock;
1220 /*
1221 * recalculate the amount of metadata blocks to reserve
1222 * in order to allocate nrblocks
1223 * worse case is one extent per block
1224 */
1226 /*
1227 * ext4_calc_metadata_amount() has side effects, which we have
1228 * to be prepared undo if we fail to claim space.
1229 */
1236 /*
1237 * We do still charge estimated metadata to the sb though;
1238 * we cannot afford to run out of free blocks.
1239 */
1245 }
1250 }
1252 /*
1253 * Reserve a single cluster located at lblock
1254 */
1256 {
1261 ext4_lblk_t save_last_lblock;
1264 /*
1265 * We will charge metadata quota at writeout time; this saves
1266 * us from metadata over-estimation, though we may go over by
1267 * a small amount in the end. Here we just reserve for data.
1268 */
1273 /*
1274 * recalculate the amount of metadata blocks to reserve
1275 * in order to allocate nrblocks
1276 * worse case is one extent per block
1277 */
1279 /*
1280 * ext4_calc_metadata_amount() has side effects, which we have
1281 * to be prepared undo if we fail to claim space.
1282 */
1289 /*
1290 * We do still charge estimated metadata to the sb though;
1291 * we cannot afford to run out of free blocks.
1292 */
1299 }
1305 }
1308 {
1319 /*
1320 * if there aren't enough reserved blocks, then the
1321 * counter is messed up somewhere. Since this
1322 * function is called from invalidate page, it's
1323 * harmless to return without any action.
1324 */
1326 "ino %lu, to_free %d with only %d reserved "
1331 }
1335 /*
1336 * We can release all of the reserved metadata blocks
1337 * only when we have written all of the delayed
1338 * allocation blocks.
1339 * Note that in case of bigalloc, i_reserved_meta_blocks,
1340 * i_reserved_data_blocks, etc. refer to number of clusters.
1341 */
1346 }
1348 /* update fs dirty data blocks counter */
1354 }
1359 {
1367 ext4_fsblk_t lblk;
1380 to_release++;
1382 }
1389 }
1391 /* If we have released all the blocks belonging to a cluster, then we
1392 * need to release the reserved space for that cluster. */
1401 num_clusters--;
1402 }
1403 }
1405 /*
1406 * Delayed allocation stuff
1407 */
1416 /*
1417 * Extent to map - this can be after first_page because that can be
1418 * fully mapped. We somewhat abuse m_flags to store whether the extent
1419 * is delalloc or unwritten.
1420 */
1423 };
1427 {
1434 /* This is necessary when next_page == 0. */
1445 }
1461 }
1463 }
1466 }
1467 }
1470 {
1493 }
1496 {
1498 }
1500 /*
1501 * This function is grabs code from the very beginning of
1502 * ext4_map_blocks, but assumes that the caller is from delayed write
1503 * time. This function looks up the requested blocks and sets the
1504 * buffer delay bit under the protection of i_data_sem.
1505 */
1509 {
1513 #ifdef ES_AGGRESSIVE_TEST
1517 #endif
1527 /* Lookup extent status tree firstly */
1534 }
1536 /*
1537 * Delayed extent could be allocated by fallocate.
1538 * So we need to check it.
1539 */
1545 }
1556 else
1559 #ifdef ES_AGGRESSIVE_TEST
1561 #endif
1563 }
1565 /*
1566 * Try to see if we can get the block without requesting a new
1567 * file system block.
1568 */
1571 /*
1572 * We will soon create blocks for this page, and let
1573 * us pretend as if the blocks aren't allocated yet.
1574 * In case of clusters, we have to handle the work
1575 * of mapping from cluster so that the reserved space
1576 * is calculated properly.
1577 */
1584 EXT4_GET_BLOCKS_NO_PUT_HOLE);
1585 else
1587 EXT4_GET_BLOCKS_NO_PUT_HOLE);
1589 add_delayed:
1592 /*
1593 * XXX: __block_prepare_write() unmaps passed block,
1594 * is it OK?
1595 */
1596 /*
1597 * If the block was allocated from previously allocated cluster,
1598 * then we don't need to reserve it again. However we still need
1599 * to reserve metadata for every block we're going to write.
1600 */
1604 /* not enough space to reserve */
1607 }
1611 /* not enough space to reserve */
1614 }
1615 }
1622 }
1624 /* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
1625 * and it should not appear on the bh->b_state.
1626 */
1638 "ES len assertion failed for inode "
1642 }
1650 }
1652 out_unlock:
1656 }
1658 /*
1659 * This is a special get_blocks_t callback which is used by
1660 * ext4_da_write_begin(). It will either return mapped block or
1661 * reserve space for a single block.
1662 *
1663 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
1664 * We also have b_blocknr = -1 and b_bdev initialized properly
1665 *
1666 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
1667 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
1668 * initialized properly.
1669 */
1672 {
1682 /*
1683 * first, we need to know whether the block is allocated already
1684 * preallocated blocks are unmapped but should treated
1685 * the same as allocated blocks.
1686 */
1695 /* A delayed write to unwritten bh should be marked
1696 * new and mapped. Mapped ensures that we don't do
1697 * get_block multiple times when we write to the same
1698 * offset and new ensures that we do proper zero out
1699 * for partial write.
1700 */
1703 }
1705 }
1708 {
1711 }
1714 {
1717 }
1721 {
1743 }
1746 }
1747 /* As soon as we unlock the page, it can go away, but we have
1748 * references to buffers so we are safe */
1756 }
1767 do_journal_get_write_access);
1770 write_end_fn);
1771 }
1783 out:
1786 }
1788 /*
1789 * Note that we don't need to start a transaction unless we're journaling data
1790 * because we should have holes filled from ext4_page_mkwrite(). We even don't
1791 * need to file the inode to the transaction's list in ordered mode because if
1792 * we are writing back data added by write(), the inode is already there and if
1793 * we are writing back data modified via mmap(), no one guarantees in which
1794 * transaction the data will hit the disk. In case we are journaling data, we
1795 * cannot start transaction directly because transaction start ranks above page
1796 * lock so we have to do some magic.
1797 *
1798 * This function can get called via...
1799 * - ext4_writepages after taking page lock (have journal handle)
1800 * - journal_submit_inode_data_buffers (no journal handle)
1801 * - shrink_page_list via the kswapd/direct reclaim (no journal handle)
1802 * - grab_page_cache when doing write_begin (have journal handle)
1803 *
1804 * We don't do any block allocation in this function. If we have page with
1805 * multiple blocks we need to write those buffer_heads that are mapped. This
1806 * is important for mmaped based write. So if we do with blocksize 1K
1807 * truncate(f, 1024);
1808 * a = mmap(f, 0, 4096);
1809 * a[0] = 'a';
1810 * truncate(f, 4096);
1811 * we have in the page first buffer_head mapped via page_mkwrite call back
1812 * but other buffer_heads would be unmapped but dirty (dirty done via the
1813 * do_wp_page). So writepage should write the first block. If we modify
1814 * the mmap area beyond 1024 we will again get a page_fault and the
1815 * page_mkwrite callback will do the block allocation and mark the
1816 * buffer_heads mapped.
1817 *
1818 * We redirty the page if we have any buffer_heads that is either delay or
1819 * unwritten in the page.
1820 *
1821 * We can get recursively called as show below.
1822 *
1823 * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1824 * ext4_writepage()
1825 *
1826 * But since we don't do any block allocation we should not deadlock.
1827 * Page also have the dirty flag cleared so we don't get recurive page_lock.
1828 */
1831 {
1833 loff_t size;
1844 else
1848 /*
1849 * We cannot do block allocation or other extent handling in this
1850 * function. If there are buffers needing that, we have to redirty
1851 * the page. But we may reach here when we do a journal commit via
1852 * journal_submit_inode_data_buffers() and in that case we must write
1853 * allocated buffers to achieve data=ordered mode guarantees.
1854 */
1856 ext4_bh_delay_or_unwritten)) {
1859 /*
1860 * For memory cleaning there's no point in writing only
1861 * some buffers. So just bail out. Warn if we came here
1862 * from direct reclaim.
1863 */
1868 }
1870 }
1873 /*
1874 * It's mmapped pagecache. Add buffers and journal it. There
1875 * doesn't seem much point in redirtying the page here.
1876 */
1885 }
1888 /* Drop io_end reference we got from init */
1891 }
1894 {
1902 else
1911 }
1913 #define BH_FLAGS ((1 << BH_Unwritten) | (1 << BH_Delay))
1915 /*
1916 * mballoc gives us at most this number of blocks...
1917 * XXX: That seems to be only a limitation of ext4_mb_normalize_request().
1918 * The rest of mballoc seems to handle chunks up to full group size.
1919 */
1920 #define MAX_WRITEPAGES_EXTENT_LEN 2048
1922 /*
1923 * mpage_add_bh_to_extent - try to add bh to extent of blocks to map
1924 *
1925 * @mpd - extent of blocks
1926 * @lblk - logical number of the block in the file
1927 * @bh - buffer head we want to add to the extent
1928 *
1929 * The function is used to collect contig. blocks in the same state. If the
1930 * buffer doesn't require mapping for writeback and we haven't started the
1931 * extent of buffers to map yet, the function returns 'true' immediately - the
1932 * caller can write the buffer right away. Otherwise the function returns true
1933 * if the block has been added to the extent, false if the block couldn't be
1934 * added.
1935 */
1938 {
1941 /* Buffer that doesn't need mapping for writeback? */
1944 /* So far no extent to map => we write the buffer right away */
1948 }
1950 /* First block in the extent? */
1956 }
1958 /* Don't go larger than mballoc is willing to allocate */
1962 /* Can we merge the block to our big extent? */
1967 }
1969 }
1971 /*
1972 * mpage_process_page_bufs - submit page buffers for IO or add them to extent
1973 *
1974 * @mpd - extent of blocks for mapping
1975 * @head - the first buffer in the page
1976 * @bh - buffer we should start processing from
1977 * @lblk - logical number of the block in the file corresponding to @bh
1978 *
1979 * Walk through page buffers from @bh upto @head (exclusive) and either submit
1980 * the page for IO if all buffers in this page were mapped and there's no
1981 * accumulated extent of buffers to map or add buffers in the page to the
1982 * extent of buffers to map. The function returns 1 if the caller can continue
1983 * by processing the next page, 0 if it should stop adding buffers to the
1984 * extent to map because we cannot extend it anymore. It can also return value
1985 * < 0 in case of error during IO submission.
1986 */
1990 ext4_lblk_t lblk)
1991 {
2001 /* Found extent to map? */
2004 /* Everything mapped so far and we hit EOF */
2006 }
2008 /* So far everything mapped? Submit the page for IO. */
2013 }
2015 }
2017 /*
2018 * mpage_map_buffers - update buffers corresponding to changed extent and
2019 * submit fully mapped pages for IO
2020 *
2021 * @mpd - description of extent to map, on return next extent to map
2022 *
2023 * Scan buffers corresponding to changed extent (we expect corresponding pages
2024 * to be already locked) and update buffer state according to new extent state.
2025 * We map delalloc buffers to their physical location, clear unwritten bits,
2026 * and mark buffers as uninit when we perform writes to uninitialized extents
2027 * and do extent conversion after IO is finished. If the last page is not fully
2028 * mapped, we update @map to the next extent in the last page that needs
2029 * mapping. Otherwise we submit the page for IO.
2030 */
2032 {
2039 ext4_lblk_t lblk;
2040 sector_t pblock;
2051 PAGEVEC_SIZE);
2059 /* Up to 'end' pages must be contiguous */
2066 /*
2067 * Buffer after end of mapped extent.
2068 * Find next buffer in the page to map.
2069 */
2072 /*
2073 * FIXME: If dioread_nolock supports
2074 * blocksize < pagesize, we need to make
2075 * sure we add size mapped so far to
2076 * io_end->size as the following call
2077 * can submit the page for IO.
2078 */
2085 }
2089 }
2093 /*
2094 * FIXME: This is going to break if dioread_nolock
2095 * supports blocksize < pagesize as we will try to
2096 * convert potentially unmapped parts of inode.
2097 */
2099 /* Page fully mapped - let IO run! */
2104 }
2105 start++;
2106 }
2108 }
2109 /* Extent fully mapped and matches with page boundary. We are done. */
2113 }
2116 {
2123 /*
2124 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
2125 * to convert an uninitialized extent to be initialized (in the case
2126 * where we have written into one or more preallocated blocks). It is
2127 * possible that we're going to need more metadata blocks than
2128 * previously reserved. However we must not fail because we're in
2129 * writeback and there is nothing we can do about it so it might result
2130 * in data loss. So use reserved blocks to allocate metadata if
2131 * possible.
2132 *
2133 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE if the blocks
2134 * in question are delalloc blocks. This affects functions in many
2135 * different parts of the allocation call path. This flag exists
2136 * primarily because we don't want to change *many* call functions, so
2137 * ext4_map_blocks() will set the EXT4_STATE_DELALLOC_RESERVED flag
2138 * once the inode's allocation semaphore is taken.
2139 */
2141 EXT4_GET_BLOCKS_METADATA_NOFAIL;
2155 }
2157 }
2166 }
2168 }
2170 /*
2171 * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length
2172 * mpd->len and submit pages underlying it for IO
2173 *
2174 * @handle - handle for journal operations
2175 * @mpd - extent to map
2176 *
2177 * The function maps extent starting at mpd->lblk of length mpd->len. If it is
2178 * delayed, blocks are allocated, if it is unwritten, we may need to convert
2179 * them to initialized or split the described range from larger unwritten
2180 * extent. Note that we need not map all the described range since allocation
2181 * can return less blocks or the range is covered by more unwritten extents. We
2182 * cannot map more because we are limited by reserved transaction credits. On
2183 * the other hand we always make sure that the last touched page is fully
2184 * mapped so that it can be written out (and thus forward progress is
2185 * guaranteed). After mapping we submit all mapped pages for IO.
2186 */
2190 {
2194 loff_t disksize;
2205 /*
2206 * Let the uper layers retry transient errors.
2207 * In the case of ENOSPC, if ext4_count_free_blocks()
2208 * is non-zero, a commit should free up blocks.
2209 */
2214 "Delayed block allocation failed for "
2215 "inode %lu at logical offset %llu with"
2221 "This should not happen!! Data will "
2225 invalidate_dirty_pages:
2228 }
2229 /*
2230 * Update buffer state, submit mapped pages, and get us new
2231 * extent to map
2232 */
2238 /*
2239 * Update on-disk size after IO is submitted. Races with
2240 * truncate are avoided by checking i_size under i_data_sem.
2241 */
2245 loff_t i_size;
2261 }
2263 }
2265 /*
2266 * Calculate the total number of credits to reserve for one writepages
2267 * iteration. This is called from ext4_writepages(). We map an extent of
2268 * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
2269 * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN +
2270 * bpp - 1 blocks in bpp different extents.
2271 */
2273 {
2278 }
2280 /*
2281 * mpage_prepare_extent_to_map - find & lock contiguous range of dirty pages
2282 * and underlying extent to map
2283 *
2284 * @mpd - where to look for pages
2285 *
2286 * Walk dirty pages in the mapping. If they are fully mapped, submit them for
2287 * IO immediately. When we find a page which isn't mapped we start accumulating
2288 * extent of buffers underlying these pages that needs mapping (formed by
2289 * either delayed or unwritten buffers). We also lock the pages containing
2290 * these buffers. The extent found is returned in @mpd structure (starting at
2291 * mpd->lblk with length mpd->len blocks).
2292 *
2293 * Note that this function can attach bios to one io_end structure which are
2294 * neither logically nor physically contiguous. Although it may seem as an
2295 * unnecessary complication, it is actually inevitable in blocksize < pagesize
2296 * case as we need to track IO to all buffers underlying a page in one io_end.
2297 */
2299 {
2308 ext4_lblk_t lblk;
2313 else
2328 /*
2329 * At this point, the page may be truncated or
2330 * invalidated (changing page->mapping to NULL), or
2331 * even swizzled back from swapper_space to tmpfs file
2332 * mapping. However, page->index will not change
2333 * because we have a reference on the page.
2334 */
2338 /* If we can't merge this page, we are done. */
2343 /*
2344 * If the page is no longer dirty, or its mapping no
2345 * longer corresponds to inode we are writing (which
2346 * means it has been truncated or invalidated), or the
2347 * page is already under writeback and we are not doing
2348 * a data integrity writeback, skip the page
2349 */
2356 }
2364 /* Add all dirty buffers to mpd */
2373 /*
2374 * Accumulated enough dirty pages? This doesn't apply
2375 * to WB_SYNC_ALL mode. For integrity sync we have to
2376 * keep going because someone may be concurrently
2377 * dirtying pages, and we might have synced a lot of
2378 * newly appeared dirty pages, but have not synced all
2379 * of the old dirty pages.
2380 */
2385 }
2388 }
2390 out:
2393 }
2397 {
2402 }
2406 {
2422 /*
2423 * No pages to write? This is mainly a kludge to avoid starting
2424 * a transaction for special inodes like journal inode on last iput()
2425 * because that could violate lock ordering on umount
2426 */
2438 }
2440 /*
2441 * If the filesystem has aborted, it is read-only, so return
2442 * right away instead of dumping stack traces later on that
2443 * will obscure the real source of the problem. We test
2444 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2445 * the latter could be true if the filesystem is mounted
2446 * read-only, and in that case, ext4_writepages should
2447 * *never* be called, so if that ever happens, we would want
2448 * the stack trace.
2449 */
2454 /*
2455 * We may need to convert up to one extent per block in
2456 * the page and we may dirty the inode.
2457 */
2459 }
2461 /*
2462 * If we have inline data and arrive here, it means that
2463 * we will soon create the block for the 1st page, so
2464 * we'd better clear the inline data here.
2465 */
2467 /* Just inode will be modified... */
2472 }
2474 EXT4_STATE_MAY_INLINE_DATA));
2477 }
2491 }
2496 retry:
2502 /* For each extent of pages we use new io_end */
2507 }
2509 /*
2510 * We have two constraints: We find one extent to map and we
2511 * must always write out whole page (makes a difference when
2512 * blocksize < pagesize) so that we don't block on IO when we
2513 * try to write out the rest of the page. Journalled mode is
2514 * not supported by delalloc.
2515 */
2519 /* start a new transaction */
2527 /* Release allocated io_end */
2530 }
2539 /*
2540 * We scanned the whole range (or exhausted
2541 * nr_to_write), submitted what was mapped and
2542 * didn't find anything needing mapping. We are
2543 * done.
2544 */
2546 }
2547 }
2549 /* Submit prepared bio */
2551 /* Unlock pages we didn't use */
2553 /* Drop our io_end reference we got from init */
2557 /*
2558 * Commit the transaction which would
2559 * free blocks released in the transaction
2560 * and try again
2561 */
2565 }
2566 /* Fatal error - ENOMEM, EIO... */
2569 }
2576 }
2578 /* Update index */
2580 /*
2581 * Set the writeback_index so that range_cyclic
2582 * mode will write it back later
2583 */
2586 out_writepages:
2590 }
2593 {
2597 /*
2598 * switch to non delalloc mode if we are running low
2599 * on free block. The free block accounting via percpu
2600 * counters can get slightly wrong with percpu_counter_batch getting
2601 * accumulated on each CPU without updating global counters
2602 * Delalloc need an accurate free block accounting. So switch
2603 * to non delalloc when we are near to error range.
2604 */
2605 free_clusters =
2607 dirty_clusters =
2609 /*
2610 * Start pushing delalloc when 1/2 of free blocks are dirty.
2611 */
2617 /*
2618 * free block count is less than 150% of dirty blocks
2619 * or free blocks is less than watermark
2620 */
2622 }
2624 }
2629 {
2632 pgoff_t index;
2642 }
2654 }
2656 /*
2657 * grab_cache_page_write_begin() can take a long time if the
2658 * system is thrashing due to memory pressure, or if the page
2659 * is being written back. So grab it first before we start
2660 * the transaction handle. This also allows us to allocate
2661 * the page (if needed) without using GFP_NOFS.
2662 */
2663 retry_grab:
2669 /*
2670 * With delayed allocation, we don't log the i_disksize update
2671 * if there is delayed block allocation. But we still need
2672 * to journalling the i_disksize update if writes to the end
2673 * of file which has an already mapped buffer.
2674 */
2675 retry_journal:
2680 }
2684 /* The page got truncated from under us */
2689 }
2690 /* In case writeback began while the page was unlocked */
2697 /*
2698 * block_write_begin may have instantiated a few blocks
2699 * outside i_size. Trim these off again. Don't need
2700 * i_size_read because we hold i_mutex.
2701 */
2711 }
2715 }
2717 /*
2718 * Check if we should update i_disksize
2719 * when write to the end of file but not require block allocation
2720 */
2723 {
2738 }
2744 {
2748 loff_t new_i_size;
2760 /*
2761 * generic_write_end() will run mark_inode_dirty() if i_size
2762 * changes. So let's piggyback the i_disksize mark_inode_dirty
2763 * into that.
2764 */
2773 /* We need to mark inode dirty even if
2774 * new_i_size is less that inode->i_size
2775 * bu greater than i_disksize.(hint delalloc)
2776 */
2778 }
2779 }
2785 page);
2786 else
2798 }
2802 {
2803 /*
2804 * Drop reserved blocks
2805 */
2812 out:
2816 }
2818 /*
2819 * Force all delayed allocation blocks to be allocated for a given inode.
2820 */
2822 {
2829 /*
2830 * We do something simple for now. The filemap_flush() will
2831 * also start triggering a write of the data blocks, which is
2832 * not strictly speaking necessary (and for users of
2833 * laptop_mode, not even desirable). However, to do otherwise
2834 * would require replicating code paths in:
2835 *
2836 * ext4_writepages() ->
2837 * write_cache_pages() ---> (via passed in callback function)
2838 * __mpage_da_writepage() -->
2839 * mpage_add_bh_to_extent()
2840 * mpage_da_map_blocks()
2841 *
2842 * The problem is that write_cache_pages(), located in
2843 * mm/page-writeback.c, marks pages clean in preparation for
2844 * doing I/O, which is not desirable if we're not planning on
2845 * doing I/O at all.
2846 *
2847 * We could call write_cache_pages(), and then redirty all of
2848 * the pages by calling redirty_page_for_writepage() but that
2849 * would be ugly in the extreme. So instead we would need to
2850 * replicate parts of the code in the above functions,
2851 * simplifying them because we wouldn't actually intend to
2852 * write out the pages, but rather only collect contiguous
2853 * logical block extents, call the multi-block allocator, and
2854 * then update the buffer heads with the block allocations.
2855 *
2856 * For now, though, we'll cheat by calling filemap_flush(),
2857 * which will map the blocks, and start the I/O, but not
2858 * actually wait for the I/O to complete.
2859 */
2861 }
2863 /*
2864 * bmap() is special. It gets used by applications such as lilo and by
2865 * the swapper to find the on-disk block of a specific piece of data.
2866 *
2867 * Naturally, this is dangerous if the block concerned is still in the
2868 * journal. If somebody makes a swapfile on an ext4 data-journaling
2869 * filesystem and enables swap, then they may get a nasty shock when the
2870 * data getting swapped to that swapfile suddenly gets overwritten by
2871 * the original zero's written out previously to the journal and
2872 * awaiting writeback in the kernel's buffer cache.
2873 *
2874 * So, if we see any bmap calls here on a modified, data-journaled file,
2875 * take extra steps to flush any blocks which might be in the cache.
2876 */
2878 {
2883 /*
2884 * We can get here for an inline file via the FIBMAP ioctl
2885 */
2891 /*
2892 * With delalloc we want to sync the file
2893 * so that we can make sure we allocate
2894 * blocks for file
2895 */
2897 }
2901 /*
2902 * This is a REALLY heavyweight approach, but the use of
2903 * bmap on dirty files is expected to be extremely rare:
2904 * only if we run lilo or swapon on a freshly made file
2905 * do we expect this to happen.
2906 *
2907 * (bmap requires CAP_SYS_RAWIO so this does not
2908 * represent an unprivileged user DOS attack --- we'd be
2909 * in trouble if mortal users could trigger this path at
2910 * will.)
2911 *
2912 * NB. EXT4_STATE_JDATA is not set on files other than
2913 * regular files. If somebody wants to bmap a directory
2914 * or symlink and gets confused because the buffer
2915 * hasn't yet been flushed to disk, they deserve
2916 * everything they get.
2917 */
2927 }
2930 }
2933 {
2946 }
2948 static int
2951 {
2954 /* If the file has inline data, no need to do readpages. */
2959 }
2963 {
2966 /* No journalling happens on data buffers when this function is used */
2970 }
2975 {
2980 /*
2981 * If it's a full truncate we just forget about the pending dirtying
2982 */
2987 }
2989 /* Wrapper for aops... */
2993 {
2995 }
2998 {
3003 /* Page has dirty journalled data -> cannot release */
3008 else
3010 }
3012 /*
3013 * ext4_get_block used when preparing for a DIO write or buffer write.
3014 * We allocate an uinitialized extent if blocks haven't been allocated.
3015 * The extent will be converted to initialized after the IO is complete.
3016 */
3019 {
3023 EXT4_GET_BLOCKS_IO_CREATE_EXT);
3024 }
3028 {
3032 EXT4_GET_BLOCKS_NO_LOCK);
3033 }
3037 {
3040 /* if not async direct IO just return */
3047 size);
3053 }
3055 /*
3056 * For ext4 extent files, ext4 will do direct-io write to holes,
3057 * preallocated extents, and those write extend the file, no need to
3058 * fall back to buffered IO.
3059 *
3060 * For holes, we fallocate those blocks, mark them as uninitialized
3061 * If those blocks were preallocated, we mark sure they are split, but
3062 * still keep the range to write as uninitialized.
3063 *
3064 * The unwritten extents will be converted to written when DIO is completed.
3065 * For async direct IO, since the IO may still pending when return, we
3066 * set up an end_io call back function, which will do the conversion
3067 * when async direct IO completed.
3068 *
3069 * If the O_DIRECT write will extend the file then add this inode to the
3070 * orphan list. So recovery will truncate it back to the original size
3071 * if the machine crashes during the write.
3072 *
3073 */
3077 {
3080 ssize_t ret;
3088 /* Use the old path for reads and writes beyond i_size. */
3094 /*
3095 * Make all waiters for direct IO properly wait also for extent
3096 * conversion. This also disallows race between truncate() and
3097 * overwrite DIO as i_dio_count needs to be incremented under i_mutex.
3098 */
3102 /* If we do a overwrite dio, i_mutex locking can be released */
3108 }
3110 /*
3111 * We could direct write to holes and fallocate.
3112 *
3113 * Allocated blocks to fill the hole are marked as
3114 * uninitialized to prevent parallel buffered read to expose
3115 * the stale data before DIO complete the data IO.
3116 *
3117 * As to previously fallocated extents, ext4 get_block will
3118 * just simply mark the buffer mapped but still keep the
3119 * extents uninitialized.
3120 *
3121 * For non AIO case, we will convert those unwritten extents
3122 * to written after return back from blockdev_direct_IO.
3123 *
3124 * For async DIO, the conversion needs to be deferred when the
3125 * IO is completed. The ext4 end_io callback function will be
3126 * called to take care of the conversion work. Here for async
3127 * case, we allocate an io_end structure to hook to the iocb.
3128 */
3136 }
3137 /*
3138 * Grab reference for DIO. Will be dropped in ext4_end_io_dio()
3139 */
3141 /*
3142 * we save the io structure for current async direct
3143 * IO, so that later ext4_map_blocks() could flag the
3144 * io structure whether there is a unwritten extents
3145 * needs to be converted when IO is completed.
3146 */
3148 }
3155 }
3159 get_block_func,
3160 ext4_end_io_dio,
3161 NULL,
3162 dio_flags);
3164 /*
3165 * Put our reference to io_end. This can free the io_end structure e.g.
3166 * in sync IO case or in case of error. It can even perform extent
3167 * conversion if all bios we submitted finished before we got here.
3168 * Note that in that case iocb->private can be already set to NULL
3169 * here.
3170 */
3174 /*
3175 * When no IO was submitted ext4_end_io_dio() was not
3176 * called so we have to put iocb's reference.
3177 */
3183 }
3184 }
3186 EXT4_STATE_DIO_UNWRITTEN)) {
3188 /*
3189 * for non AIO case, since the IO is already
3190 * completed, we could do the conversion right here
3191 */
3197 }
3199 retake_lock:
3202 /* take i_mutex locking again if we do a ovewrite dio */
3206 }
3209 }
3214 {
3217 ssize_t ret;
3219 /*
3220 * If we are doing data journalling we don't support O_DIRECT
3221 */
3225 /* Let buffer I/O handle the inline data case. */
3232 else
3237 }
3239 /*
3240 * Pages can be marked dirty completely asynchronously from ext4's journalling
3241 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
3242 * much here because ->set_page_dirty is called under VFS locks. The page is
3243 * not necessarily locked.
3244 *
3245 * We cannot just dirty the page and leave attached buffers clean, because the
3246 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
3247 * or jbddirty because all the journalling code will explode.
3248 *
3249 * So what we do is to mark the page "pending dirty" and next time writepage
3250 * is called, propagate that into the buffers appropriately.
3251 */
3253 {
3256 }
3272 };
3288 };
3304 };
3307 {
3320 }
3323 else
3325 }
3327 /*
3328 * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
3329 * up to the end of the block which corresponds to `from'.
3330 * This required during truncate. We need to physically zero the tail end
3331 * of that block so it doesn't yield old data if the file is later grown.
3332 */
3335 {
3345 }
3347 /*
3348 * ext4_block_zero_page_range() zeros out a mapping of length 'length'
3349 * starting from file offset 'from'. The range to be zero'd must
3350 * be contained with in one block. If the specified range exceeds
3351 * the end of the block it will be shortened to end of the block
3352 * that cooresponds to 'from'
3353 */
3356 {
3360 ext4_lblk_t iblock;
3374 /*
3375 * correct length if it does not fall between
3376 * 'from' and the end of the block
3377 */
3386 /* Find the buffer that contains "offset" */
3391 iblock++;
3393 }
3397 }
3401 /* unmapped? It's a hole - nothing to do */
3405 }
3406 }
3408 /* Ok, it's mapped. Make sure it's up-to-date */
3416 /* Uhhuh. Read error. Complain and punt. */
3419 }
3425 }
3436 }
3438 unlock:
3442 }
3446 {
3460 /* Handle partial zero within the single block */
3466 }
3467 /* Handle partial zero out on the start of the range */
3473 }
3474 /* Handle partial zero out on the end of the range */
3480 }
3483 {
3491 }
3493 /*
3494 * ext4_punch_hole: punches a hole in a file by releaseing the blocks
3495 * associated with the given offset and length
3496 *
3497 * @inode: File inode
3498 * @offset: The offset where the hole will begin
3499 * @len: The length of the hole
3500 *
3501 * Returns: 0 on success or negative on failure
3502 */
3505 {
3518 /* TODO: Add support for bigalloc file systems */
3520 }
3524 /*
3525 * Write out all dirty pages to avoid race conditions
3526 * Then release them.
3527 */
3533 }
3536 /* It's not possible punch hole on append only file */
3540 }
3544 }
3546 /* No need to punch hole beyond i_size */
3550 /*
3551 * If the hole extends beyond i_size, set the hole
3552 * to end after the page that contains i_size
3553 */
3557 offset;
3558 }
3562 /*
3563 * Attach jinode to inode for jbd2 if we do any zeroing of
3564 * partial block
3565 */
3570 }
3575 /* Now release the pages and zero block aligned part of pages*/
3578 last_block_offset);
3580 /* Wait all existing dio workers, newcomers will block on i_mutex */
3586 else
3593 }
3596 length);
3604 /* If there are no blocks to remove, return now */
3616 }
3621 else
3623 stop_block);
3631 out_stop:
3633 out_dio:
3635 out_mutex:
3638 }
3641 {
3654 }
3658 }
3663 }
3665 /*
3666 * ext4_truncate()
3667 *
3668 * We block out ext4_get_block() block instantiations across the entire
3669 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3670 * simultaneously on behalf of the same inode.
3671 *
3672 * As we work through the truncate and commit bits of it to the journal there
3673 * is one core, guiding principle: the file's tree must always be consistent on
3674 * disk. We must be able to restart the truncate after a crash.
3675 *
3676 * The file's tree may be transiently inconsistent in memory (although it
3677 * probably isn't), but whenever we close off and commit a journal transaction,
3678 * the contents of (the filesystem + the journal) must be consistent and
3679 * restartable. It's pretty simple, really: bottom up, right to left (although
3680 * left-to-right works OK too).
3681 *
3682 * Note that at recovery time, journal replay occurs *before* the restart of
3683 * truncate against the orphan inode list.
3684 *
3685 * The committed inode has the new, desired i_size (which is the same as
3686 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see
3687 * that this inode's truncate did not complete and it will again call
3688 * ext4_truncate() to have another go. So there will be instantiated blocks
3689 * to the right of the truncation point in a crashed ext4 filesystem. But
3690 * that's fine - as long as they are linked from the inode, the post-crash
3691 * ext4_truncate() run will find them and release them.
3692 */
3694 {
3700 /*
3701 * There is a possibility that we're either freeing the inode
3702 * or it completely new indode. In those cases we might not
3703 * have i_mutex locked because it's not necessary.
3704 */
3723 }
3725 /* If we zero-out tail of the page, we have to create jinode for jbd2 */
3729 }
3733 else
3740 }
3745 /*
3746 * We add the inode to the orphan list, so that if this
3747 * truncate spans multiple transactions, and we crash, we will
3748 * resume the truncate when the filesystem recovers. It also
3749 * marks the inode dirty, to catch the new size.
3750 *
3751 * Implication: the file must always be in a sane, consistent
3752 * truncatable state while each transaction commits.
3753 */
3763 else
3771 out_stop:
3772 /*
3773 * If this was a simple ftruncate() and the file will remain alive,
3774 * then we need to clear up the orphan record which we created above.
3775 * However, if this was a real unlink then we were called by
3776 * ext4_delete_inode(), and we allow that function to clean up the
3777 * orphan info for us.
3778 */
3787 }
3789 /*
3790 * ext4_get_inode_loc returns with an extra refcount against the inode's
3791 * underlying buffer_head on success. If 'in_mem' is true, we have all
3792 * data in memory that is needed to recreate the on-disk version of this
3793 * inode.
3794 */
3797 {
3801 ext4_fsblk_t block;
3813 /*
3814 * Figure out the offset within the block group inode table
3815 */
3828 /*
3829 * If the buffer has the write error flag, we have failed
3830 * to write out another inode in the same block. In this
3831 * case, we don't have to read the block because we may
3832 * read the old inode data successfully.
3833 */
3838 /* someone brought it uptodate while we waited */
3841 }
3843 /*
3844 * If we have all information of the inode in memory and this
3845 * is the only valid inode in the block, we need not read the
3846 * block.
3847 */
3854 /* Is the inode bitmap in cache? */
3859 /*
3860 * If the inode bitmap isn't in cache then the
3861 * optimisation may end up performing two reads instead
3862 * of one, so skip it.
3863 */
3867 }
3873 }
3876 /* all other inodes are free, so skip I/O */
3881 }
3882 }
3884 make_io:
3885 /*
3886 * If we need to do any I/O, try to pre-readahead extra
3887 * blocks from the inode table.
3888 */
3895 /* s_inode_readahead_blks is always a power of 2 */
3908 }
3910 /*
3911 * There are other valid inodes in the buffer, this inode
3912 * has in-inode xattrs, or we don't have this inode in memory.
3913 * Read the block from disk.
3914 */
3925 }
3926 }
3927 has_buffer:
3930 }
3933 {
3934 /* We have all inode data except xattrs in memory here. */
3937 }
3940 {
3956 }
3958 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3960 {
3969 EXT4_DIRSYNC_FL);
3981 }
3985 {
3986 blkcnt_t i_blocks ;
3991 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
3992 /* we are using combined 48 bit field */
3996 /* i_blocks represent file system block size */
4000 }
4003 }
4004 }
4009 {
4017 }
4020 {
4028 uid_t i_uid;
4029 gid_t i_gid;
4054 }
4058 /* Precompute checksum seed for inode metadata */
4060 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
4062 __u32 csum;
4069 }
4075 }
4083 }
4092 /* We now have enough fields to check if the inode was active or not.
4093 * This is needed because nfsd might try to access dead inodes
4094 * the test is that same one that e2fsck uses
4095 * NeilBrown 1999oct15
4096 */
4101 /* this inode is deleted */
4104 }
4105 /* The only unlinked inodes we let through here have
4106 * valid i_mode and are being read by the orphan
4107 * recovery code: that's fine, we're about to complete
4108 * the process of deleting those.
4109 * OR it is the EXT4_BOOT_LOADER_INO which is
4110 * not initialized on a new filesystem. */
4111 }
4120 #ifdef CONFIG_QUOTA
4122 #endif
4126 /*
4127 * NOTE! The in-memory inode i_data array is in little-endian order
4128 * even on big-endian machines: we do NOT byteswap the block numbers!
4129 */
4134 /*
4135 * Set transaction id's of transactions that have to be committed
4136 * to finish f[data]sync. We set them to currently running transaction
4137 * as we cannot be sure that the inode or some of its metadata isn't
4138 * part of the transaction - the inode could have been reclaimed and
4139 * now it is reread from disk.
4140 */
4143 tid_t tid;
4148 else
4152 else
4157 }
4161 /* The extra space is currently unused. Use it. */
4163 EXT4_GOOD_OLD_INODE_SIZE;
4166 }
4167 }
4179 }
4193 /* Validate extent which is part of inode */
4198 /* Validate block references which are part of inode */
4200 }
4201 }
4220 }
4227 else
4236 }
4242 bad_inode:
4246 }
4251 {
4257 /*
4258 * i_blocks can be represented in a 32 bit variable
4259 * as multiple of 512 bytes
4260 */
4265 }
4270 /*
4271 * i_blocks can be represented in a 48 bit variable
4272 * as multiple of 512 bytes
4273 */
4279 /* i_block is stored in file system block size */
4283 }
4285 }
4287 /*
4288 * Post the struct inode info into an on-disk inode location in the
4289 * buffer-cache. This gobbles the caller's reference to the
4290 * buffer_head in the inode location struct.
4291 *
4292 * The caller must have write access to iloc->bh.
4293 */
4297 {
4303 uid_t i_uid;
4304 gid_t i_gid;
4306 /* For fields not not tracking in the in-memory inode,
4307 * initialise them to zero for new inodes. */
4318 /*
4319 * Fix up interoperability with old kernels. Otherwise, old inodes get
4320 * re-used with the upper 16 bits of the uid/gid intact
4321 */
4330 }
4336 }
4356 }
4360 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4363 /* If this is the first large file
4364 * created, add a flag to the superblock.
4365 */
4372 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4375 }
4376 }
4388 }
4392 }
4400 }
4411 out_brelse:
4415 }
4417 /*
4418 * ext4_write_inode()
4419 *
4420 * We are called from a few places:
4421 *
4422 * - Within generic_file_write() for O_SYNC files.
4423 * Here, there will be no transaction running. We wait for any running
4424 * transaction to commit.
4425 *
4426 * - Within sys_sync(), kupdate and such.
4427 * We wait on commit, if tol to.
4428 *
4429 * - Within prune_icache() (PF_MEMALLOC == true)
4430 * Here we simply return. We can't afford to block kswapd on the
4431 * journal commit.
4432 *
4433 * In all cases it is actually safe for us to return without doing anything,
4434 * because the inode has been copied into a raw inode buffer in
4435 * ext4_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
4436 * knfsd.
4437 *
4438 * Note that we are absolutely dependent upon all inode dirtiers doing the
4439 * right thing: they *must* call mark_inode_dirty() after dirtying info in
4440 * which we are interested.
4441 *
4442 * It would be a bug for them to not do this. The code:
4443 *
4444 * mark_inode_dirty(inode)
4445 * stuff();
4446 * inode->i_size = expr;
4447 *
4448 * is in error because a kswapd-driven write_inode() could occur while
4449 * `stuff()' is running, and the new i_size will be lost. Plus the inode
4450 * will no longer be on the superblock's dirty inode list.
4451 */
4453 {
4464 }
4466 /*
4467 * No need to force transaction in WB_SYNC_NONE mode. Also
4468 * ext4_sync_fs() will force the commit after everything is
4469 * written.
4470 */
4481 /*
4482 * sync(2) will flush the whole buffer cache. No need to do
4483 * it here separately for each inode.
4484 */
4491 }
4493 }
4495 }
4497 /*
4498 * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
4499 * buffers that are attached to a page stradding i_size and are undergoing
4500 * commit. In that case we have to wait for commit to finish and try again.
4501 */
4503 {
4511 /*
4512 * All buffers in the last page remain valid? Then there's nothing to
4513 * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
4514 * blocksize case
4515 */
4536 }
4537 }
4539 /*
4540 * ext4_setattr()
4541 *
4542 * Called from notify_change.
4543 *
4544 * We want to trap VFS attempts to truncate the file as soon as
4545 * possible. In particular, we want to make sure that when the VFS
4546 * shrinks i_size, we put the inode on the orphan list and modify
4547 * i_disksize immediately, so that during the subsequent flushing of
4548 * dirty pages and freeing of disk blocks, we can guarantee that any
4549 * commit will leave the blocks being flushed in an unused state on
4550 * disk. (On recovery, the inode will get truncated and the blocks will
4551 * be freed, so we have a strong guarantee that no future commit will
4552 * leave these blocks visible to the user.)
4553 *
4554 * Another thing we have to assure is that if we are in ordered mode
4555 * and inode is still attached to the committing transaction, we must
4556 * we start writeout of all the dirty pages which are being truncated.
4557 * This way we are sure that all the data written in the previous
4558 * transaction are already on disk (truncate waits for pages under
4559 * writeback).
4560 *
4561 * Called with inode->i_mutex down.
4562 */
4564 {
4580 /* (user+group)*(old+new) structure, inode write (sb,
4581 * inode block, ? - but truncate inode update has it) */
4588 }
4593 }
4594 /* Update corresponding info in inode so that everything is in
4595 * one transaction */
4602 }
4612 }
4624 }
4629 }
4633 }
4639 /*
4640 * We have to update i_size under i_data_sem together
4641 * with i_disksize to avoid races with writeback code
4642 * running ext4_wb_update_i_disksize().
4643 */
4651 }
4655 /*
4656 * Blocks are going to be removed from the inode. Wait
4657 * for dio in flight. Temporarily disable
4658 * dioread_nolock to prevent livelock.
4659 */
4667 }
4668 /*
4669 * Truncate pagecache after we've waited for commit
4670 * in data=journal mode to make pages freeable.
4671 */
4673 }
4674 /*
4675 * We want to call ext4_truncate() even if attr->ia_size ==
4676 * inode->i_size for cases like truncation of fallocated space
4677 */
4684 }
4686 /*
4687 * If the call to ext4_truncate failed to get a transaction handle at
4688 * all, we need to clean up the in-core orphan list manually.
4689 */
4696 err_out:
4701 }
4705 {
4712 /*
4713 * We can't update i_blocks if the block allocation is delayed
4714 * otherwise in the case of system crash before the real block
4715 * allocation is done, we will have i_blocks inconsistent with
4716 * on-disk file blocks.
4717 * We always keep i_blocks updated together with real
4718 * allocation. But to not confuse with user, stat
4719 * will return the blocks that include the delayed allocation
4720 * blocks for this file.
4721 */
4727 }
4731 {
4735 }
4737 /*
4738 * Account for index blocks, block groups bitmaps and block group
4739 * descriptor blocks if modify datablocks and index blocks
4740 * worse case, the indexs blocks spread over different block groups
4741 *
4742 * If datablocks are discontiguous, they are possible to spread over
4743 * different block groups too. If they are contiguous, with flexbg,
4744 * they could still across block group boundary.
4745 *
4746 * Also account for superblock, inode, quota and xattr blocks
4747 */
4750 {
4756 /*
4757 * How many index blocks need to touch to map @lblocks logical blocks
4758 * to @pextents physical extents?
4759 */
4764 /*
4765 * Now let's see how many group bitmaps and group descriptors need
4766 * to account
4767 */
4775 /* bitmaps and block group descriptor blocks */
4778 /* Blocks for super block, inode, quota and xattr blocks */
4782 }
4784 /*
4785 * Calculate the total number of credits to reserve to fit
4786 * the modification of a single pages into a single transaction,
4787 * which may include multiple chunks of block allocations.
4788 *
4789 * This could be called via ext4_write_begin()
4790 *
4791 * We need to consider the worse case, when
4792 * one new block per extent.
4793 */
4795 {
4801 /* Account for data blocks for journalled mode */
4805 }
4807 /*
4808 * Calculate the journal credits for a chunk of data modification.
4809 *
4810 * This is called from DIO, fallocate or whoever calling
4811 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4812 *
4813 * journal buffers for data blocks are not included here, as DIO
4814 * and fallocate do no need to journal data buffers.
4815 */
4817 {
4819 }
4821 /*
4822 * The caller must have previously called ext4_reserve_inode_write().
4823 * Give this, we know that the caller already has write access to iloc->bh.
4824 */
4827 {
4833 /* the do_update_inode consumes one bh->b_count */
4836 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4840 }
4842 /*
4843 * On success, We end up with an outstanding reference count against
4844 * iloc->bh. This _must_ be cleaned up later.
4845 */
4847 int
4850 {
4860 }
4861 }
4864 }
4866 /*
4867 * Expand an inode by new_extra_isize bytes.
4868 * Returns 0 on success or negative error number on failure.
4869 */
4874 {
4885 /* No extended attributes present */
4889 new_extra_isize);
4892 }
4894 /* try to expand with EAs present */
4897 }
4899 /*
4900 * What we do here is to mark the in-core inode as clean with respect to inode
4901 * dirtiness (it may still be data-dirty).
4902 * This means that the in-core inode may be reaped by prune_icache
4903 * without having to perform any I/O. This is a very good thing,
4904 * because *any* task may call prune_icache - even ones which
4905 * have a transaction open against a different journal.
4906 *
4907 * Is this cheating? Not really. Sure, we haven't written the
4908 * inode out, but prune_icache isn't a user-visible syncing function.
4909 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4910 * we start and wait on commits.
4911 */
4913 {
4925 /*
4926 * We need extra buffer credits since we may write into EA block
4927 * with this same handle. If journal_extend fails, then it will
4928 * only result in a minor loss of functionality for that inode.
4929 * If this is felt to be critical, then e2fsck should be run to
4930 * force a large enough s_min_extra_isize.
4931 */
4939 EXT4_STATE_NO_EXPAND);
4943 "Unable to expand inode %lu. Delete"
4946 mnt_count =
4948 }
4949 }
4950 }
4951 }
4955 }
4957 /*
4958 * ext4_dirty_inode() is called from __mark_inode_dirty()
4959 *
4960 * We're really interested in the case where a file is being extended.
4961 * i_size has been changed by generic_commit_write() and we thus need
4962 * to include the updated inode in the current transaction.
4963 *
4964 * Also, dquot_alloc_block() will always dirty the inode when blocks
4965 * are allocated to the file.
4966 *
4967 * If the inode is marked synchronous, we don't honour that here - doing
4968 * so would cause a commit on atime updates, which we don't bother doing.
4969 * We handle synchronous inodes at the highest possible level.
4970 */
4972 {
4982 out:
4984 }
4986 #if 0
4987 /*
4988 * Bind an inode's backing buffer_head into this transaction, to prevent
4989 * it from being flushed to disk early. Unlike
4990 * ext4_reserve_inode_write, this leaves behind no bh reference and
4991 * returns no iloc structure, so the caller needs to repeat the iloc
4992 * lookup to mark the inode dirty later.
4993 */
4995 {
5006 NULL,
5009 }
5010 }
5013 }
5014 #endif
5017 {
5022 /*
5023 * We have to be very careful here: changing a data block's
5024 * journaling status dynamically is dangerous. If we write a
5025 * data block to the journal, change the status and then delete
5026 * that block, we risk forgetting to revoke the old log record
5027 * from the journal and so a subsequent replay can corrupt data.
5028 * So, first we make sure that the journal is empty and that
5029 * nobody is changing anything.
5030 */
5037 /* We have to allocate physical blocks for delalloc blocks
5038 * before flushing journal. otherwise delalloc blocks can not
5039 * be allocated any more. even more truncate on delalloc blocks
5040 * could trigger BUG by flushing delalloc blocks in journal.
5041 * There is no delalloc block in non-journal data mode.
5042 */
5047 }
5049 /* Wait for all existing dio workers */
5055 /*
5056 * OK, there are no updates running now, and all cached data is
5057 * synced to disk. We are now in a completely consistent state
5058 * which doesn't have anything in the journal, and we know that
5059 * no filesystem updates are running, so it is safe to modify
5060 * the inode's in-core data-journaling state flag now.
5061 */
5068 }
5074 /* Finally we can mark the inode as dirty. */
5086 }
5089 {
5091 }
5094 {
5096 loff_t size;
5108 /* Delalloc case is easy... */
5114 ext4_da_get_block_prep);
5118 }
5122 /* Page got truncated from under us? */
5127 }
5131 else
5133 /*
5134 * Return if we have all the buffers mapped. This avoids the need to do
5135 * journal_start/journal_stop which can block and take a long time
5136 */
5140 ext4_bh_unmapped)) {
5141 /* Wait so that we don't change page under IO */
5145 }
5146 }
5148 /* OK, we need to fill the hole... */
5151 else
5153 retry_alloc:
5159 }
5168 }
5170 }
5174 out_ret:
5176 out:
5179 }