| blob | 5beca5c5413e6ee146a4d48508785ec8bd28bc47 |
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/highuid.h>
24 #include <linux/pagemap.h>
25 #include <linux/quotaops.h>
26 #include <linux/string.h>
27 #include <linux/buffer_head.h>
28 #include <linux/writeback.h>
29 #include <linux/pagevec.h>
30 #include <linux/mpage.h>
31 #include <linux/namei.h>
32 #include <linux/uio.h>
33 #include <linux/bio.h>
34 #include <linux/workqueue.h>
35 #include <linux/kernel.h>
36 #include <linux/printk.h>
37 #include <linux/slab.h>
38 #include <linux/bitops.h>
45 #include <trace/events/ext4.h>
47 #define MPAGE_DA_EXTENT_TAIL 0x01
51 {
53 __u16 csum_lo;
55 __u32 csum;
63 }
74 }
78 {
91 else
95 }
99 {
100 __u32 csum;
112 }
115 loff_t new_size)
116 {
118 /*
119 * If jinode is zero, then we never opened the file for
120 * writing, so there's no need to call
121 * jbd2_journal_begin_ordered_truncate() since there's no
122 * outstanding writes we need to flush.
123 */
128 new_size);
129 }
138 /*
139 * Test whether an inode is a fast symlink.
140 */
142 {
150 }
152 /*
153 * Restart the transaction associated with *handle. This does a commit,
154 * so before we call here everything must be consistently dirtied against
155 * this transaction.
156 */
159 {
162 /*
163 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
164 * moment, get_block can be called only for blocks inside i_size since
165 * page cache has been already dropped and writes are blocked by
166 * i_mutex. So we can safely drop the i_data_sem here.
167 */
176 }
178 /*
179 * Called at the last iput() if i_nlink is zero.
180 */
182 {
189 /*
190 * When journalling data dirty buffers are tracked only in the
191 * journal. So although mm thinks everything is clean and
192 * ready for reaping the inode might still have some pages to
193 * write in the running transaction or waiting to be
194 * checkpointed. Thus calling jbd2_journal_invalidatepage()
195 * (via truncate_inode_pages()) to discard these buffers can
196 * cause data loss. Also even if we did not discard these
197 * buffers, we would have no way to find them after the inode
198 * is reaped and thus user could see stale data if he tries to
199 * read them before the transaction is checkpointed. So be
200 * careful and force everything to disk here... We use
201 * ei->i_datasync_tid to store the newest transaction
202 * containing inode's data.
203 *
204 * Note that directories do not have this problem because they
205 * don't use page cache.
206 */
215 }
220 }
232 /*
233 * Protect us against freezing - iput() caller didn't have to have any
234 * protection against it
235 */
241 /*
242 * If we're going to skip the normal cleanup, we still need to
243 * make sure that the in-core orphan linked list is properly
244 * cleaned up.
245 */
249 }
259 }
263 /*
264 * ext4_ext_truncate() doesn't reserve any slop when it
265 * restarts journal transactions; therefore there may not be
266 * enough credits left in the handle to remove the inode from
267 * the orphan list and set the dtime field.
268 */
276 stop_handle:
281 }
282 }
284 /*
285 * Kill off the orphan record which ext4_truncate created.
286 * AKPM: I think this can be inside the above `if'.
287 * Note that ext4_orphan_del() has to be able to cope with the
288 * deletion of a non-existent orphan - this is because we don't
289 * know if ext4_truncate() actually created an orphan record.
290 * (Well, we could do this if we need to, but heck - it works)
291 */
295 /*
296 * One subtle ordering requirement: if anything has gone wrong
297 * (transaction abort, IO errors, whatever), then we can still
298 * do these next steps (the fs will already have been marked as
299 * having errors), but we can't free the inode if the mark_dirty
300 * fails.
301 */
303 /* If that failed, just do the required in-core inode clear. */
305 else
310 no_delete:
312 }
314 #ifdef CONFIG_QUOTA
316 {
318 }
319 #endif
321 /*
322 * Called with i_data_sem down, which is important since we can call
323 * ext4_discard_preallocations() from here.
324 */
327 {
340 }
342 /* Update per-inode reservations */
348 /* Update quota subsystem for data blocks */
352 /*
353 * We did fallocate with an offset that is already delayed
354 * allocated. So on delayed allocated writeback we should
355 * not re-claim the quota for fallocated blocks.
356 */
358 }
360 /*
361 * If we have done all the pending block allocations and if
362 * there aren't any writers on the inode, we can discard the
363 * inode's preallocations.
364 */
368 }
373 {
377 "lblock %lu mapped to illegal pblock "
381 }
383 }
385 #define check_block_validity(inode, map) \
386 __check_block_validity((inode), __func__, __LINE__, (map))
388 #ifdef ES_AGGRESSIVE_TEST
394 {
398 /*
399 * There is a race window that the result is not the same.
400 * e.g. xfstests #223 when dioread_nolock enables. The reason
401 * is that we lookup a block mapping in extent status tree with
402 * out taking i_data_sem. So at the time the unwritten extent
403 * could be converted.
404 */
409 EXT4_GET_BLOCKS_KEEP_SIZE);
412 EXT4_GET_BLOCKS_KEEP_SIZE);
413 }
417 /*
418 * We don't check m_len because extent will be collpased in status
419 * tree. So the m_len might not equal.
420 */
425 "es_cached ex [%d/%d/%llu/%x] != "
431 }
432 }
435 /*
436 * The ext4_map_blocks() function tries to look up the requested blocks,
437 * and returns if the blocks are already mapped.
438 *
439 * Otherwise it takes the write lock of the i_data_sem and allocate blocks
440 * and store the allocated blocks in the result buffer head and mark it
441 * mapped.
442 *
443 * If file type is extents based, it will call ext4_ext_map_blocks(),
444 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
445 * based files
446 *
447 * On success, it returns the number of blocks being mapped or allocated.
448 * if create==0 and the blocks are pre-allocated and unwritten block,
449 * the result buffer head is unmapped. If the create ==1, it will make sure
450 * the buffer head is mapped.
451 *
452 * It returns 0 if plain look up failed (blocks have not been allocated), in
453 * that case, buffer head is unmapped
454 *
455 * It returns the error in case of allocation failure.
456 */
459 {
463 #ifdef ES_AGGRESSIVE_TEST
467 #endif
474 /*
475 * ext4_map_blocks returns an int, and m_len is an unsigned int
476 */
480 /* We can handle the block number less than EXT_MAX_BLOCKS */
484 /* Lookup extent status tree firstly */
499 }
500 #ifdef ES_AGGRESSIVE_TEST
503 #endif
505 }
507 /*
508 * Try to see if we can get the block without requesting a new
509 * file system block.
510 */
515 EXT4_GET_BLOCKS_KEEP_SIZE);
518 EXT4_GET_BLOCKS_KEEP_SIZE);
519 }
525 "ES len assertion failed for inode "
529 }
542 }
546 found:
551 }
553 /* If it is only a block(s) look up */
557 /*
558 * Returns if the blocks have already allocated
559 *
560 * Note that if blocks have been preallocated
561 * ext4_ext_get_block() returns the create = 0
562 * with buffer head unmapped.
563 */
565 /*
566 * If we need to convert extent to unwritten
567 * we continue and do the actual work in
568 * ext4_ext_map_blocks()
569 */
573 /*
574 * Here we clear m_flags because after allocating an new extent,
575 * it will be set again.
576 */
579 /*
580 * New blocks allocate and/or writing to unwritten extent
581 * will possibly result in updating i_data, so we take
582 * the write lock of i_data_sem, and call get_block()
583 * with create == 1 flag.
584 */
587 /*
588 * We need to check for EXT4 here because migrate
589 * could have changed the inode type in between
590 */
597 /*
598 * We allocated new blocks which will result in
599 * i_data's format changing. Force the migrate
600 * to fail by clearing migrate flags
601 */
603 }
605 /*
606 * Update reserved blocks/metadata blocks after successful
607 * block allocation which had been deferred till now. We don't
608 * support fallocate for non extent files. So we can update
609 * reserve space here.
610 */
614 }
621 "ES len assertion failed for inode "
625 }
627 /*
628 * If the extent has been zeroed out, we don't need to update
629 * extent status tree.
630 */
635 }
647 }
649 has_zeroout:
655 }
657 }
659 /*
660 * Update EXT4_MAP_FLAGS in bh->b_state. For buffer heads attached to pages
661 * we have to be careful as someone else may be manipulating b_state as well.
662 */
664 {
670 /* Dummy buffer_head? Set non-atomically. */
674 }
675 /*
676 * Someone else may be modifying b_state. Be careful! This is ugly but
677 * once we get rid of using bh as a container for mapping information
678 * to pass to / from get_block functions, this can go away.
679 */
685 }
687 /* Maximum number of blocks we map for direct IO at once. */
688 #define DIO_MAX_BLOCKS 4096
692 {
705 /* Direct IO write... */
710 dio_credits);
714 }
716 }
725 /*
726 * dgc: I suspect unwritten conversion on ext4+DAX is
727 * fundamentally broken here when there are concurrent
728 * read/write in progress on this inode.
729 */
733 }
738 }
742 }
746 {
749 }
751 /*
752 * `handle' can be NULL if create is zero
753 */
756 {
780 /*
781 * Now that we do not always journal data, we should
782 * keep in mind whether this should always journal the
783 * new buffer as metadata. For now, regular file
784 * writes use ext4_get_block instead, so it's not a
785 * problem.
786 */
793 }
797 }
806 errout:
809 }
813 {
827 }
836 {
852 }
856 }
858 }
860 /*
861 * To preserve ordering, it is essential that the hole instantiation and
862 * the data write be encapsulated in a single transaction. We cannot
863 * close off a transaction and start a new one between the ext4_get_block()
864 * and the commit_write(). So doing the jbd2_journal_start at the start of
865 * prepare_write() is the right place.
866 *
867 * Also, this function can nest inside ext4_writepage(). In that case, we
868 * *know* that ext4_writepage() has generated enough buffer credits to do the
869 * whole page. So we won't block on the journal in that case, which is good,
870 * because the caller may be PF_MEMALLOC.
871 *
872 * By accident, ext4 can be reentered when a transaction is open via
873 * quota file writes. If we were to commit the transaction while thus
874 * reentered, there can be a deadlock - we would be holding a quota
875 * lock, and the commit would never complete if another thread had a
876 * transaction open and was blocking on the quota lock - a ranking
877 * violation.
878 *
879 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
880 * will _not_ run commit under these circumstances because handle->h_ref
881 * is elevated. We'll still have enough credits for the tiny quotafile
882 * write.
883 */
886 {
892 /*
893 * __block_write_begin() could have dirtied some buffers. Clean
894 * the dirty bit as jbd2_journal_get_write_access() could complain
895 * otherwise about fs integrity issues. Setting of the dirty bit
896 * by __block_write_begin() isn't a real problem here as we clear
897 * the bit before releasing a page lock and thus writeback cannot
898 * ever write the buffer.
899 */
907 }
912 #ifdef CONFIG_EXT4_FS_ENCRYPTION
915 {
920 sector_t block;
945 }
947 }
963 }
968 }
969 }
974 }
982 }
983 }
984 /*
985 * If we issued read requests, let them complete.
986 */
991 }
997 }
998 #endif
1003 {
1009 pgoff_t index;
1013 /*
1014 * Reserve one block more for addition to orphan list in case
1015 * we allocate blocks but write fails for some reason
1016 */
1029 }
1031 /*
1032 * grab_cache_page_write_begin() can take a long time if the
1033 * system is thrashing due to memory pressure, or if the page
1034 * is being written back. So grab it first before we start
1035 * the transaction handle. This also allows us to allocate
1036 * the page (if needed) without using GFP_NOFS.
1037 */
1038 retry_grab:
1044 retry_journal:
1049 }
1053 /* The page got truncated from under us */
1058 }
1059 /* In case writeback began while the page was unlocked */
1062 #ifdef CONFIG_EXT4_FS_ENCRYPTION
1065 ext4_get_block_write);
1066 else
1068 ext4_get_block);
1069 #else
1072 else
1074 #endif
1078 do_journal_get_write_access);
1079 }
1083 /*
1084 * __block_write_begin may have instantiated a few blocks
1085 * outside i_size. Trim these off again. Don't need
1086 * i_size_read because we hold i_mutex.
1087 *
1088 * Add inode to orphan list in case we crash before
1089 * truncate finishes
1090 */
1097 /*
1098 * If truncate failed early the inode might
1099 * still be on the orphan list; we need to
1100 * make sure the inode is removed from the
1101 * orphan list in that case.
1102 */
1105 }
1112 }
1115 }
1117 /* For write_end() in data=journal mode */
1119 {
1128 }
1130 /*
1131 * We need to pick up the new inode size which generic_commit_write gave us
1132 * `file' can be NULL - eg, when called from page_symlink().
1133 *
1134 * ext4 never places buffers on inode->i_mapping->private_list. metadata
1135 * buffers are managed internally.
1136 */
1141 {
1155 }
1156 }
1167 /*
1168 * it's important to update i_size while still holding page lock:
1169 * page writeout could otherwise come in and zero beyond i_size.
1170 */
1177 /*
1178 * Don't mark the inode dirty under page lock. First, it unnecessarily
1179 * makes the holding time of page lock longer. Second, it forces lock
1180 * ordering of page lock and transaction start for journaling
1181 * filesystems.
1182 */
1187 /* if we have allocated more blocks and copied
1188 * less. We will have blocks allocated outside
1189 * inode->i_size. So truncate them
1190 */
1192 errout:
1199 /*
1200 * If truncate failed early the inode might still be
1201 * on the orphan list; we need to make sure the inode
1202 * is removed from the orphan list in that case.
1203 */
1206 }
1209 }
1215 {
1238 }
1244 }
1258 }
1261 /* if we have allocated more blocks and copied
1262 * less. We will have blocks allocated outside
1263 * inode->i_size. So truncate them
1264 */
1272 /*
1273 * If truncate failed early the inode might still be
1274 * on the orphan list; we need to make sure the inode
1275 * is removed from the orphan list in that case.
1276 */
1279 }
1282 }
1284 /*
1285 * Reserve a single cluster located at lblock
1286 */
1288 {
1294 /*
1295 * We will charge metadata quota at writeout time; this saves
1296 * us from metadata over-estimation, though we may go over by
1297 * a small amount in the end. Here we just reserve for data.
1298 */
1303 /*
1304 * recalculate the amount of metadata blocks to reserve
1305 * in order to allocate nrblocks
1306 * worse case is one extent per block
1307 */
1309 /*
1310 * ext4_calc_metadata_amount() has side effects, which we have
1311 * to be prepared undo if we fail to claim space.
1312 */
1320 }
1325 }
1328 {
1339 /*
1340 * if there aren't enough reserved blocks, then the
1341 * counter is messed up somewhere. Since this
1342 * function is called from invalidate page, it's
1343 * harmless to return without any action.
1344 */
1346 "ino %lu, to_free %d with only %d reserved "
1351 }
1354 /* update fs dirty data blocks counter */
1360 }
1365 {
1373 ext4_fsblk_t lblk;
1386 to_release++;
1387 contiguous_blks++;
1393 contiguous_blks;
1396 }
1404 }
1406 /* If we have released all the blocks belonging to a cluster, then we
1407 * need to release the reserved space for that cluster. */
1416 num_clusters--;
1417 }
1418 }
1420 /*
1421 * Delayed allocation stuff
1422 */
1431 /*
1432 * Extent to map - this can be after first_page because that can be
1433 * fully mapped. We somewhat abuse m_flags to store whether the extent
1434 * is delalloc or unwritten.
1435 */
1438 };
1442 {
1449 /* This is necessary when next_page == 0. */
1460 }
1476 }
1478 }
1481 }
1482 }
1485 {
1504 }
1507 {
1509 }
1511 /*
1512 * This function is grabs code from the very beginning of
1513 * ext4_map_blocks, but assumes that the caller is from delayed write
1514 * time. This function looks up the requested blocks and sets the
1515 * buffer delay bit under the protection of i_data_sem.
1516 */
1520 {
1524 #ifdef ES_AGGRESSIVE_TEST
1528 #endif
1538 /* Lookup extent status tree firstly */
1544 }
1546 /*
1547 * Delayed extent could be allocated by fallocate.
1548 * So we need to check it.
1549 */
1555 }
1566 else
1569 #ifdef ES_AGGRESSIVE_TEST
1571 #endif
1573 }
1575 /*
1576 * Try to see if we can get the block without requesting a new
1577 * file system block.
1578 */
1584 else
1587 add_delayed:
1590 /*
1591 * XXX: __block_prepare_write() unmaps passed block,
1592 * is it OK?
1593 */
1594 /*
1595 * If the block was allocated from previously allocated cluster,
1596 * then we don't need to reserve it again. However we still need
1597 * to reserve metadata for every block we're going to write.
1598 */
1603 /* not enough space to reserve */
1606 }
1607 }
1614 }
1625 "ES len assertion failed for inode "
1629 }
1637 }
1639 out_unlock:
1643 }
1645 /*
1646 * This is a special get_block_t callback which is used by
1647 * ext4_da_write_begin(). It will either return mapped block or
1648 * reserve space for a single block.
1649 *
1650 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
1651 * We also have b_blocknr = -1 and b_bdev initialized properly
1652 *
1653 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
1654 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
1655 * initialized properly.
1656 */
1659 {
1669 /*
1670 * first, we need to know whether the block is allocated already
1671 * preallocated blocks are unmapped but should treated
1672 * the same as allocated blocks.
1673 */
1682 /* A delayed write to unwritten bh should be marked
1683 * new and mapped. Mapped ensures that we don't do
1684 * get_block multiple times when we write to the same
1685 * offset and new ensures that we do proper zero out
1686 * for partial write.
1687 */
1690 }
1692 }
1695 {
1698 }
1701 {
1704 }
1708 {
1730 }
1733 }
1734 /*
1735 * We need to release the page lock before we start the
1736 * journal, so grab a reference so the page won't disappear
1737 * out from under us.
1738 */
1748 }
1754 /* The page got truncated from under us */
1758 }
1768 do_journal_get_write_access);
1771 write_end_fn);
1772 }
1784 out:
1786 out_no_pagelock:
1789 }
1791 /*
1792 * Note that we don't need to start a transaction unless we're journaling data
1793 * because we should have holes filled from ext4_page_mkwrite(). We even don't
1794 * need to file the inode to the transaction's list in ordered mode because if
1795 * we are writing back data added by write(), the inode is already there and if
1796 * we are writing back data modified via mmap(), no one guarantees in which
1797 * transaction the data will hit the disk. In case we are journaling data, we
1798 * cannot start transaction directly because transaction start ranks above page
1799 * lock so we have to do some magic.
1800 *
1801 * This function can get called via...
1802 * - ext4_writepages after taking page lock (have journal handle)
1803 * - journal_submit_inode_data_buffers (no journal handle)
1804 * - shrink_page_list via the kswapd/direct reclaim (no journal handle)
1805 * - grab_page_cache when doing write_begin (have journal handle)
1806 *
1807 * We don't do any block allocation in this function. If we have page with
1808 * multiple blocks we need to write those buffer_heads that are mapped. This
1809 * is important for mmaped based write. So if we do with blocksize 1K
1810 * truncate(f, 1024);
1811 * a = mmap(f, 0, 4096);
1812 * a[0] = 'a';
1813 * truncate(f, 4096);
1814 * we have in the page first buffer_head mapped via page_mkwrite call back
1815 * but other buffer_heads would be unmapped but dirty (dirty done via the
1816 * do_wp_page). So writepage should write the first block. If we modify
1817 * the mmap area beyond 1024 we will again get a page_fault and the
1818 * page_mkwrite callback will do the block allocation and mark the
1819 * buffer_heads mapped.
1820 *
1821 * We redirty the page if we have any buffer_heads that is either delay or
1822 * unwritten in the page.
1823 *
1824 * We can get recursively called as show below.
1825 *
1826 * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1827 * ext4_writepage()
1828 *
1829 * But since we don't do any block allocation we should not deadlock.
1830 * Page also have the dirty flag cleared so we don't get recurive page_lock.
1831 */
1834 {
1836 loff_t size;
1847 else
1851 /*
1852 * We cannot do block allocation or other extent handling in this
1853 * function. If there are buffers needing that, we have to redirty
1854 * the page. But we may reach here when we do a journal commit via
1855 * journal_submit_inode_data_buffers() and in that case we must write
1856 * allocated buffers to achieve data=ordered mode guarantees.
1857 */
1859 ext4_bh_delay_or_unwritten)) {
1862 /*
1863 * For memory cleaning there's no point in writing only
1864 * some buffers. So just bail out. Warn if we came here
1865 * from direct reclaim.
1866 */
1871 }
1873 }
1876 /*
1877 * It's mmapped pagecache. Add buffers and journal it. There
1878 * doesn't seem much point in redirtying the page here.
1879 */
1888 }
1891 /* Drop io_end reference we got from init */
1894 }
1897 {
1905 else
1914 }
1916 #define BH_FLAGS ((1 << BH_Unwritten) | (1 << BH_Delay))
1918 /*
1919 * mballoc gives us at most this number of blocks...
1920 * XXX: That seems to be only a limitation of ext4_mb_normalize_request().
1921 * The rest of mballoc seems to handle chunks up to full group size.
1922 */
1923 #define MAX_WRITEPAGES_EXTENT_LEN 2048
1925 /*
1926 * mpage_add_bh_to_extent - try to add bh to extent of blocks to map
1927 *
1928 * @mpd - extent of blocks
1929 * @lblk - logical number of the block in the file
1930 * @bh - buffer head we want to add to the extent
1931 *
1932 * The function is used to collect contig. blocks in the same state. If the
1933 * buffer doesn't require mapping for writeback and we haven't started the
1934 * extent of buffers to map yet, the function returns 'true' immediately - the
1935 * caller can write the buffer right away. Otherwise the function returns true
1936 * if the block has been added to the extent, false if the block couldn't be
1937 * added.
1938 */
1941 {
1944 /* Buffer that doesn't need mapping for writeback? */
1947 /* So far no extent to map => we write the buffer right away */
1951 }
1953 /* First block in the extent? */
1959 }
1961 /* Don't go larger than mballoc is willing to allocate */
1965 /* Can we merge the block to our big extent? */
1970 }
1972 }
1974 /*
1975 * mpage_process_page_bufs - submit page buffers for IO or add them to extent
1976 *
1977 * @mpd - extent of blocks for mapping
1978 * @head - the first buffer in the page
1979 * @bh - buffer we should start processing from
1980 * @lblk - logical number of the block in the file corresponding to @bh
1981 *
1982 * Walk through page buffers from @bh upto @head (exclusive) and either submit
1983 * the page for IO if all buffers in this page were mapped and there's no
1984 * accumulated extent of buffers to map or add buffers in the page to the
1985 * extent of buffers to map. The function returns 1 if the caller can continue
1986 * by processing the next page, 0 if it should stop adding buffers to the
1987 * extent to map because we cannot extend it anymore. It can also return value
1988 * < 0 in case of error during IO submission.
1989 */
1993 ext4_lblk_t lblk)
1994 {
2004 /* Found extent to map? */
2007 /* Everything mapped so far and we hit EOF */
2009 }
2011 /* So far everything mapped? Submit the page for IO. */
2016 }
2018 }
2020 /*
2021 * mpage_map_buffers - update buffers corresponding to changed extent and
2022 * submit fully mapped pages for IO
2023 *
2024 * @mpd - description of extent to map, on return next extent to map
2025 *
2026 * Scan buffers corresponding to changed extent (we expect corresponding pages
2027 * to be already locked) and update buffer state according to new extent state.
2028 * We map delalloc buffers to their physical location, clear unwritten bits,
2029 * and mark buffers as uninit when we perform writes to unwritten extents
2030 * and do extent conversion after IO is finished. If the last page is not fully
2031 * mapped, we update @map to the next extent in the last page that needs
2032 * mapping. Otherwise we submit the page for IO.
2033 */
2035 {
2042 ext4_lblk_t lblk;
2043 sector_t pblock;
2054 PAGEVEC_SIZE);
2062 /* Up to 'end' pages must be contiguous */
2069 /*
2070 * Buffer after end of mapped extent.
2071 * Find next buffer in the page to map.
2072 */
2075 /*
2076 * FIXME: If dioread_nolock supports
2077 * blocksize < pagesize, we need to make
2078 * sure we add size mapped so far to
2079 * io_end->size as the following call
2080 * can submit the page for IO.
2081 */
2088 }
2092 }
2096 /*
2097 * FIXME: This is going to break if dioread_nolock
2098 * supports blocksize < pagesize as we will try to
2099 * convert potentially unmapped parts of inode.
2100 */
2102 /* Page fully mapped - let IO run! */
2107 }
2108 start++;
2109 }
2111 }
2112 /* Extent fully mapped and matches with page boundary. We are done. */
2116 }
2119 {
2126 /*
2127 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
2128 * to convert an unwritten extent to be initialized (in the case
2129 * where we have written into one or more preallocated blocks). It is
2130 * possible that we're going to need more metadata blocks than
2131 * previously reserved. However we must not fail because we're in
2132 * writeback and there is nothing we can do about it so it might result
2133 * in data loss. So use reserved blocks to allocate metadata if
2134 * possible.
2135 *
2136 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE if
2137 * the blocks in question are delalloc blocks. This indicates
2138 * that the blocks and quotas has already been checked when
2139 * the data was copied into the page cache.
2140 */
2142 EXT4_GET_BLOCKS_METADATA_NOFAIL;
2157 }
2159 }
2168 }
2170 }
2172 /*
2173 * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length
2174 * mpd->len and submit pages underlying it for IO
2175 *
2176 * @handle - handle for journal operations
2177 * @mpd - extent to map
2178 * @give_up_on_write - we set this to true iff there is a fatal error and there
2179 * is no hope of writing the data. The caller should discard
2180 * dirty pages to avoid infinite loops.
2181 *
2182 * The function maps extent starting at mpd->lblk of length mpd->len. If it is
2183 * delayed, blocks are allocated, if it is unwritten, we may need to convert
2184 * them to initialized or split the described range from larger unwritten
2185 * extent. Note that we need not map all the described range since allocation
2186 * can return less blocks or the range is covered by more unwritten extents. We
2187 * cannot map more because we are limited by reserved transaction credits. On
2188 * the other hand we always make sure that the last touched page is fully
2189 * mapped so that it can be written out (and thus forward progress is
2190 * guaranteed). After mapping we submit all mapped pages for IO.
2191 */
2195 {
2199 loff_t disksize;
2211 /*
2212 * Let the uper layers retry transient errors.
2213 * In the case of ENOSPC, if ext4_count_free_blocks()
2214 * is non-zero, a commit should free up blocks.
2215 */
2221 }
2223 "Delayed block allocation failed for "
2224 "inode %lu at logical offset %llu with"
2230 "This should not happen!! Data will "
2234 invalidate_dirty_pages:
2237 }
2239 /*
2240 * Update buffer state, submit mapped pages, and get us new
2241 * extent to map
2242 */
2248 update_disksize:
2249 /*
2250 * Update on-disk size after IO is submitted. Races with
2251 * truncate are avoided by checking i_size under i_data_sem.
2252 */
2256 loff_t i_size;
2272 }
2274 }
2276 /*
2277 * Calculate the total number of credits to reserve for one writepages
2278 * iteration. This is called from ext4_writepages(). We map an extent of
2279 * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
2280 * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN +
2281 * bpp - 1 blocks in bpp different extents.
2282 */
2284 {
2289 }
2291 /*
2292 * mpage_prepare_extent_to_map - find & lock contiguous range of dirty pages
2293 * and underlying extent to map
2294 *
2295 * @mpd - where to look for pages
2296 *
2297 * Walk dirty pages in the mapping. If they are fully mapped, submit them for
2298 * IO immediately. When we find a page which isn't mapped we start accumulating
2299 * extent of buffers underlying these pages that needs mapping (formed by
2300 * either delayed or unwritten buffers). We also lock the pages containing
2301 * these buffers. The extent found is returned in @mpd structure (starting at
2302 * mpd->lblk with length mpd->len blocks).
2303 *
2304 * Note that this function can attach bios to one io_end structure which are
2305 * neither logically nor physically contiguous. Although it may seem as an
2306 * unnecessary complication, it is actually inevitable in blocksize < pagesize
2307 * case as we need to track IO to all buffers underlying a page in one io_end.
2308 */
2310 {
2320 ext4_lblk_t lblk;
2325 else
2340 /*
2341 * At this point, the page may be truncated or
2342 * invalidated (changing page->mapping to NULL), or
2343 * even swizzled back from swapper_space to tmpfs file
2344 * mapping. However, page->index will not change
2345 * because we have a reference on the page.
2346 */
2350 /*
2351 * Accumulated enough dirty pages? This doesn't apply
2352 * to WB_SYNC_ALL mode. For integrity sync we have to
2353 * keep going because someone may be concurrently
2354 * dirtying pages, and we might have synced a lot of
2355 * newly appeared dirty pages, but have not synced all
2356 * of the old dirty pages.
2357 */
2361 /* If we can't merge this page, we are done. */
2366 /*
2367 * If the page is no longer dirty, or its mapping no
2368 * longer corresponds to inode we are writing (which
2369 * means it has been truncated or invalidated), or the
2370 * page is already under writeback and we are not doing
2371 * a data integrity writeback, skip the page
2372 */
2379 }
2387 /* Add all dirty buffers to mpd */
2395 left--;
2396 }
2399 }
2401 out:
2404 }
2408 {
2413 }
2417 {
2433 /*
2434 * No pages to write? This is mainly a kludge to avoid starting
2435 * a transaction for special inodes like journal inode on last iput()
2436 * because that could violate lock ordering on umount
2437 */
2448 }
2450 /*
2451 * If the filesystem has aborted, it is read-only, so return
2452 * right away instead of dumping stack traces later on that
2453 * will obscure the real source of the problem. We test
2454 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2455 * the latter could be true if the filesystem is mounted
2456 * read-only, and in that case, ext4_writepages should
2457 * *never* be called, so if that ever happens, we would want
2458 * the stack trace.
2459 */
2463 }
2466 /*
2467 * We may need to convert up to one extent per block in
2468 * the page and we may dirty the inode.
2469 */
2471 }
2473 /*
2474 * If we have inline data and arrive here, it means that
2475 * we will soon create the block for the 1st page, so
2476 * we'd better clear the inline data here.
2477 */
2479 /* Just inode will be modified... */
2484 }
2486 EXT4_STATE_MAY_INLINE_DATA));
2489 }
2503 }
2508 retry:
2514 /* For each extent of pages we use new io_end */
2519 }
2521 /*
2522 * We have two constraints: We find one extent to map and we
2523 * must always write out whole page (makes a difference when
2524 * blocksize < pagesize) so that we don't block on IO when we
2525 * try to write out the rest of the page. Journalled mode is
2526 * not supported by delalloc.
2527 */
2531 /* start a new transaction */
2539 /* Release allocated io_end */
2542 }
2551 /*
2552 * We scanned the whole range (or exhausted
2553 * nr_to_write), submitted what was mapped and
2554 * didn't find anything needing mapping. We are
2555 * done.
2556 */
2558 }
2559 }
2560 /*
2561 * Caution: If the handle is synchronous,
2562 * ext4_journal_stop() can wait for transaction commit
2563 * to finish which may depend on writeback of pages to
2564 * complete or on page lock to be released. In that
2565 * case, we have to wait until after after we have
2566 * submitted all the IO, released page locks we hold,
2567 * and dropped io_end reference (for extent conversion
2568 * to be able to complete) before stopping the handle.
2569 */
2573 }
2574 /* Submit prepared bio */
2576 /* Unlock pages we didn't use */
2578 /*
2579 * Drop our io_end reference we got from init. We have
2580 * to be careful and use deferred io_end finishing if
2581 * we are still holding the transaction as we can
2582 * release the last reference to io_end which may end
2583 * up doing unwritten extent conversion.
2584 */
2592 /*
2593 * Commit the transaction which would
2594 * free blocks released in the transaction
2595 * and try again
2596 */
2600 }
2601 /* Fatal error - ENOMEM, EIO... */
2604 }
2611 }
2613 /* Update index */
2615 /*
2616 * Set the writeback_index so that range_cyclic
2617 * mode will write it back later
2618 */
2621 out_writepages:
2625 }
2628 {
2632 /*
2633 * switch to non delalloc mode if we are running low
2634 * on free block. The free block accounting via percpu
2635 * counters can get slightly wrong with percpu_counter_batch getting
2636 * accumulated on each CPU without updating global counters
2637 * Delalloc need an accurate free block accounting. So switch
2638 * to non delalloc when we are near to error range.
2639 */
2640 free_clusters =
2642 dirty_clusters =
2644 /*
2645 * Start pushing delalloc when 1/2 of free blocks are dirty.
2646 */
2652 /*
2653 * free block count is less than 150% of dirty blocks
2654 * or free blocks is less than watermark
2655 */
2657 }
2659 }
2661 /* We always reserve for an inode update; the superblock could be there too */
2663 {
2665 EXT4_FEATURE_RO_COMPAT_LARGE_FILE)))
2671 /* We might need to update the superblock to set LARGE_FILE */
2673 }
2678 {
2681 pgoff_t index;
2691 }
2703 }
2705 /*
2706 * grab_cache_page_write_begin() can take a long time if the
2707 * system is thrashing due to memory pressure, or if the page
2708 * is being written back. So grab it first before we start
2709 * the transaction handle. This also allows us to allocate
2710 * the page (if needed) without using GFP_NOFS.
2711 */
2712 retry_grab:
2718 /*
2719 * With delayed allocation, we don't log the i_disksize update
2720 * if there is delayed block allocation. But we still need
2721 * to journalling the i_disksize update if writes to the end
2722 * of file which has an already mapped buffer.
2723 */
2724 retry_journal:
2730 }
2734 /* The page got truncated from under us */
2739 }
2740 /* In case writeback began while the page was unlocked */
2743 #ifdef CONFIG_EXT4_FS_ENCRYPTION
2745 ext4_da_get_block_prep);
2746 #else
2748 #endif
2752 /*
2753 * block_write_begin may have instantiated a few blocks
2754 * outside i_size. Trim these off again. Don't need
2755 * i_size_read because we hold i_mutex.
2756 */
2766 }
2770 }
2772 /*
2773 * Check if we should update i_disksize
2774 * when write to the end of file but not require block allocation
2775 */
2778 {
2793 }
2799 {
2803 loff_t new_i_size;
2815 /*
2816 * generic_write_end() will run mark_inode_dirty() if i_size
2817 * changes. So let's piggyback the i_disksize mark_inode_dirty
2818 * into that.
2819 */
2825 /* We need to mark inode dirty even if
2826 * new_i_size is less that inode->i_size
2827 * bu greater than i_disksize.(hint delalloc)
2828 */
2830 }
2831 }
2837 page);
2838 else
2850 }
2854 {
2855 /*
2856 * Drop reserved blocks
2857 */
2864 out:
2868 }
2870 /*
2871 * Force all delayed allocation blocks to be allocated for a given inode.
2872 */
2874 {
2880 /*
2881 * We do something simple for now. The filemap_flush() will
2882 * also start triggering a write of the data blocks, which is
2883 * not strictly speaking necessary (and for users of
2884 * laptop_mode, not even desirable). However, to do otherwise
2885 * would require replicating code paths in:
2886 *
2887 * ext4_writepages() ->
2888 * write_cache_pages() ---> (via passed in callback function)
2889 * __mpage_da_writepage() -->
2890 * mpage_add_bh_to_extent()
2891 * mpage_da_map_blocks()
2892 *
2893 * The problem is that write_cache_pages(), located in
2894 * mm/page-writeback.c, marks pages clean in preparation for
2895 * doing I/O, which is not desirable if we're not planning on
2896 * doing I/O at all.
2897 *
2898 * We could call write_cache_pages(), and then redirty all of
2899 * the pages by calling redirty_page_for_writepage() but that
2900 * would be ugly in the extreme. So instead we would need to
2901 * replicate parts of the code in the above functions,
2902 * simplifying them because we wouldn't actually intend to
2903 * write out the pages, but rather only collect contiguous
2904 * logical block extents, call the multi-block allocator, and
2905 * then update the buffer heads with the block allocations.
2906 *
2907 * For now, though, we'll cheat by calling filemap_flush(),
2908 * which will map the blocks, and start the I/O, but not
2909 * actually wait for the I/O to complete.
2910 */
2912 }
2914 /*
2915 * bmap() is special. It gets used by applications such as lilo and by
2916 * the swapper to find the on-disk block of a specific piece of data.
2917 *
2918 * Naturally, this is dangerous if the block concerned is still in the
2919 * journal. If somebody makes a swapfile on an ext4 data-journaling
2920 * filesystem and enables swap, then they may get a nasty shock when the
2921 * data getting swapped to that swapfile suddenly gets overwritten by
2922 * the original zero's written out previously to the journal and
2923 * awaiting writeback in the kernel's buffer cache.
2924 *
2925 * So, if we see any bmap calls here on a modified, data-journaled file,
2926 * take extra steps to flush any blocks which might be in the cache.
2927 */
2929 {
2934 /*
2935 * We can get here for an inline file via the FIBMAP ioctl
2936 */
2942 /*
2943 * With delalloc we want to sync the file
2944 * so that we can make sure we allocate
2945 * blocks for file
2946 */
2948 }
2952 /*
2953 * This is a REALLY heavyweight approach, but the use of
2954 * bmap on dirty files is expected to be extremely rare:
2955 * only if we run lilo or swapon on a freshly made file
2956 * do we expect this to happen.
2957 *
2958 * (bmap requires CAP_SYS_RAWIO so this does not
2959 * represent an unprivileged user DOS attack --- we'd be
2960 * in trouble if mortal users could trigger this path at
2961 * will.)
2962 *
2963 * NB. EXT4_STATE_JDATA is not set on files other than
2964 * regular files. If somebody wants to bmap a directory
2965 * or symlink and gets confused because the buffer
2966 * hasn't yet been flushed to disk, they deserve
2967 * everything they get.
2968 */
2978 }
2981 }
2984 {
2997 }
2999 static int
3002 {
3005 /* If the file has inline data, no need to do readpages. */
3010 }
3014 {
3017 /* No journalling happens on data buffers when this function is used */
3021 }
3026 {
3031 /*
3032 * If it's a full truncate we just forget about the pending dirtying
3033 */
3038 }
3040 /* Wrapper for aops... */
3044 {
3046 }
3049 {
3054 /* Page has dirty journalled data -> cannot release */
3059 else
3061 }
3063 /*
3064 * ext4_get_block used when preparing for a DIO write or buffer write.
3065 * We allocate an uinitialized extent if blocks haven't been allocated.
3066 * The extent will be converted to initialized after the IO is complete.
3067 */
3070 {
3074 EXT4_GET_BLOCKS_IO_CREATE_EXT);
3075 }
3079 {
3083 EXT4_GET_BLOCKS_NO_LOCK);
3084 }
3088 {
3091 /* if not async direct IO just return */
3098 size);
3104 }
3106 /*
3107 * For ext4 extent files, ext4 will do direct-io write to holes,
3108 * preallocated extents, and those write extend the file, no need to
3109 * fall back to buffered IO.
3110 *
3111 * For holes, we fallocate those blocks, mark them as unwritten
3112 * If those blocks were preallocated, we mark sure they are split, but
3113 * still keep the range to write as unwritten.
3114 *
3115 * The unwritten extents will be converted to written when DIO is completed.
3116 * For async direct IO, since the IO may still pending when return, we
3117 * set up an end_io call back function, which will do the conversion
3118 * when async direct IO completed.
3119 *
3120 * If the O_DIRECT write will extend the file then add this inode to the
3121 * orphan list. So recovery will truncate it back to the original size
3122 * if the machine crashes during the write.
3123 *
3124 */
3126 loff_t offset)
3127 {
3130 ssize_t ret;
3138 /* Use the old path for reads and writes beyond i_size. */
3144 /*
3145 * Make all waiters for direct IO properly wait also for extent
3146 * conversion. This also disallows race between truncate() and
3147 * overwrite DIO as i_dio_count needs to be incremented under i_mutex.
3148 */
3152 /* If we do a overwrite dio, i_mutex locking can be released */
3158 }
3160 /*
3161 * We could direct write to holes and fallocate.
3162 *
3163 * Allocated blocks to fill the hole are marked as
3164 * unwritten to prevent parallel buffered read to expose
3165 * the stale data before DIO complete the data IO.
3166 *
3167 * As to previously fallocated extents, ext4 get_block will
3168 * just simply mark the buffer mapped but still keep the
3169 * extents unwritten.
3170 *
3171 * For non AIO case, we will convert those unwritten extents
3172 * to written after return back from blockdev_direct_IO.
3173 *
3174 * For async DIO, the conversion needs to be deferred when the
3175 * IO is completed. The ext4 end_io callback function will be
3176 * called to take care of the conversion work. Here for async
3177 * case, we allocate an io_end structure to hook to the iocb.
3178 */
3189 }
3190 /*
3191 * Grab reference for DIO. Will be dropped in
3192 * ext4_end_io_dio()
3193 */
3195 /*
3196 * we save the io structure for current async direct
3197 * IO, so that later ext4_map_blocks() could flag the
3198 * io structure whether there is a unwritten extents
3199 * needs to be converted when IO is completed.
3200 */
3202 }
3205 }
3206 #ifdef CONFIG_EXT4_FS_ENCRYPTION
3208 #endif
3212 else
3215 get_block_func,
3218 /*
3219 * Put our reference to io_end. This can free the io_end structure e.g.
3220 * in sync IO case or in case of error. It can even perform extent
3221 * conversion if all bios we submitted finished before we got here.
3222 * Note that in that case iocb->private can be already set to NULL
3223 * here.
3224 */
3228 /*
3229 * When no IO was submitted ext4_end_io_dio() was not
3230 * called so we have to put iocb's reference.
3231 */
3237 }
3238 }
3240 EXT4_STATE_DIO_UNWRITTEN)) {
3242 /*
3243 * for non AIO case, since the IO is already
3244 * completed, we could do the conversion right here
3245 */
3251 }
3253 retake_lock:
3256 /* take i_mutex locking again if we do a ovewrite dio */
3260 }
3263 }
3266 loff_t offset)
3267 {
3271 ssize_t ret;
3273 #ifdef CONFIG_EXT4_FS_ENCRYPTION
3276 #endif
3278 /*
3279 * If we are doing data journalling we don't support O_DIRECT
3280 */
3284 /* Let buffer I/O handle the inline data case. */
3291 else
3295 }
3297 /*
3298 * Pages can be marked dirty completely asynchronously from ext4's journalling
3299 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
3300 * much here because ->set_page_dirty is called under VFS locks. The page is
3301 * not necessarily locked.
3302 *
3303 * We cannot just dirty the page and leave attached buffers clean, because the
3304 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
3305 * or jbddirty because all the journalling code will explode.
3306 *
3307 * So what we do is to mark the page "pending dirty" and next time writepage
3308 * is called, propagate that into the buffers appropriately.
3309 */
3311 {
3314 }
3330 };
3346 };
3362 };
3365 {
3378 }
3381 else
3383 }
3387 {
3391 ext4_lblk_t iblock;
3409 /* Find the buffer that contains "offset" */
3414 iblock++;
3416 }
3420 }
3424 /* unmapped? It's a hole - nothing to do */
3428 }
3429 }
3431 /* Ok, it's mapped. Make sure it's up-to-date */
3439 /* Uhhuh. Read error. Complain and punt. */
3444 /* We expect the key to be set. */
3448 }
3449 }
3455 }
3466 }
3468 unlock:
3472 }
3474 /*
3475 * ext4_block_zero_page_range() zeros out a mapping of length 'length'
3476 * starting from file offset 'from'. The range to be zero'd must
3477 * be contained with in one block. If the specified range exceeds
3478 * the end of the block it will be shortened to end of the block
3479 * that cooresponds to 'from'
3480 */
3483 {
3489 /*
3490 * correct length if it does not fall between
3491 * 'from' and the end of the block
3492 */
3499 }
3501 /*
3502 * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
3503 * up to the end of the block which corresponds to `from'.
3504 * This required during truncate. We need to physically zero the tail end
3505 * of that block so it doesn't yield old data if the file is later grown.
3506 */
3509 {
3519 }
3523 {
3537 /* Handle partial zero within the single block */
3543 }
3544 /* Handle partial zero out on the start of the range */
3550 }
3551 /* Handle partial zero out on the end of the range */
3557 }
3560 {
3568 }
3570 /*
3571 * We have to make sure i_disksize gets properly updated before we truncate
3572 * page cache due to hole punching or zero range. Otherwise i_disksize update
3573 * can get lost as it may have been postponed to submission of writeback but
3574 * that will never happen after we truncate page cache.
3575 */
3577 loff_t len)
3578 {
3597 }
3599 /*
3600 * ext4_punch_hole: punches a hole in a file by releaseing the blocks
3601 * associated with the given offset and length
3602 *
3603 * @inode: File inode
3604 * @offset: The offset where the hole will begin
3605 * @len: The length of the hole
3606 *
3607 * Returns: 0 on success or negative on failure
3608 */
3611 {
3625 /*
3626 * Write out all dirty pages to avoid race conditions
3627 * Then release them.
3628 */
3634 }
3638 /* No need to punch hole beyond i_size */
3642 /*
3643 * If the hole extends beyond i_size, set the hole
3644 * to end after the page that contains i_size
3645 */
3649 offset;
3650 }
3654 /*
3655 * Attach jinode to inode for jbd2 if we do any zeroing of
3656 * partial block
3657 */
3662 }
3664 /* Wait all existing dio workers, newcomers will block on i_mutex */
3668 /*
3669 * Prevent page faults from reinstantiating pages we have released from
3670 * page cache.
3671 */
3676 /* Now release the pages and zero block aligned part of pages*/
3682 last_block_offset);
3683 }
3687 else
3694 }
3697 length);
3705 /* If there are no blocks to remove, return now */
3717 }
3722 else
3724 stop_block);
3732 out_stop:
3734 out_dio:
3737 out_mutex:
3740 }
3743 {
3756 }
3760 }
3765 }
3767 /*
3768 * ext4_truncate()
3769 *
3770 * We block out ext4_get_block() block instantiations across the entire
3771 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3772 * simultaneously on behalf of the same inode.
3773 *
3774 * As we work through the truncate and commit bits of it to the journal there
3775 * is one core, guiding principle: the file's tree must always be consistent on
3776 * disk. We must be able to restart the truncate after a crash.
3777 *
3778 * The file's tree may be transiently inconsistent in memory (although it
3779 * probably isn't), but whenever we close off and commit a journal transaction,
3780 * the contents of (the filesystem + the journal) must be consistent and
3781 * restartable. It's pretty simple, really: bottom up, right to left (although
3782 * left-to-right works OK too).
3783 *
3784 * Note that at recovery time, journal replay occurs *before* the restart of
3785 * truncate against the orphan inode list.
3786 *
3787 * The committed inode has the new, desired i_size (which is the same as
3788 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see
3789 * that this inode's truncate did not complete and it will again call
3790 * ext4_truncate() to have another go. So there will be instantiated blocks
3791 * to the right of the truncation point in a crashed ext4 filesystem. But
3792 * that's fine - as long as they are linked from the inode, the post-crash
3793 * ext4_truncate() run will find them and release them.
3794 */
3796 {
3802 /*
3803 * There is a possibility that we're either freeing the inode
3804 * or it's a completely new inode. In those cases we might not
3805 * have i_mutex locked because it's not necessary.
3806 */
3825 }
3827 /* If we zero-out tail of the page, we have to create jinode for jbd2 */
3831 }
3835 else
3842 }
3847 /*
3848 * We add the inode to the orphan list, so that if this
3849 * truncate spans multiple transactions, and we crash, we will
3850 * resume the truncate when the filesystem recovers. It also
3851 * marks the inode dirty, to catch the new size.
3852 *
3853 * Implication: the file must always be in a sane, consistent
3854 * truncatable state while each transaction commits.
3855 */
3865 else
3873 out_stop:
3874 /*
3875 * If this was a simple ftruncate() and the file will remain alive,
3876 * then we need to clear up the orphan record which we created above.
3877 * However, if this was a real unlink then we were called by
3878 * ext4_evict_inode(), and we allow that function to clean up the
3879 * orphan info for us.
3880 */
3889 }
3891 /*
3892 * ext4_get_inode_loc returns with an extra refcount against the inode's
3893 * underlying buffer_head on success. If 'in_mem' is true, we have all
3894 * data in memory that is needed to recreate the on-disk version of this
3895 * inode.
3896 */
3899 {
3903 ext4_fsblk_t block;
3915 /*
3916 * Figure out the offset within the block group inode table
3917 */
3930 /*
3931 * If the buffer has the write error flag, we have failed
3932 * to write out another inode in the same block. In this
3933 * case, we don't have to read the block because we may
3934 * read the old inode data successfully.
3935 */
3940 /* someone brought it uptodate while we waited */
3943 }
3945 /*
3946 * If we have all information of the inode in memory and this
3947 * is the only valid inode in the block, we need not read the
3948 * block.
3949 */
3956 /* Is the inode bitmap in cache? */
3961 /*
3962 * If the inode bitmap isn't in cache then the
3963 * optimisation may end up performing two reads instead
3964 * of one, so skip it.
3965 */
3969 }
3975 }
3978 /* all other inodes are free, so skip I/O */
3983 }
3984 }
3986 make_io:
3987 /*
3988 * If we need to do any I/O, try to pre-readahead extra
3989 * blocks from the inode table.
3990 */
3997 /* s_inode_readahead_blks is always a power of 2 */
4010 }
4012 /*
4013 * There are other valid inodes in the buffer, this inode
4014 * has in-inode xattrs, or we don't have this inode in memory.
4015 * Read the block from disk.
4016 */
4027 }
4028 }
4029 has_buffer:
4032 }
4035 {
4036 /* We have all inode data except xattrs in memory here. */
4039 }
4042 {
4060 }
4062 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
4064 {
4073 EXT4_DIRSYNC_FL);
4085 }
4089 {
4090 blkcnt_t i_blocks ;
4095 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
4096 /* we are using combined 48 bit field */
4100 /* i_blocks represent file system block size */
4104 }
4107 }
4108 }
4113 {
4121 }
4124 {
4132 uid_t i_uid;
4133 gid_t i_gid;
4158 }
4162 /* Precompute checksum seed for inode metadata */
4165 __u32 csum;
4172 }
4178 }
4186 }
4195 /* We now have enough fields to check if the inode was active or not.
4196 * This is needed because nfsd might try to access dead inodes
4197 * the test is that same one that e2fsck uses
4198 * NeilBrown 1999oct15
4199 */
4204 /* this inode is deleted */
4207 }
4208 /* The only unlinked inodes we let through here have
4209 * valid i_mode and are being read by the orphan
4210 * recovery code: that's fine, we're about to complete
4211 * the process of deleting those.
4212 * OR it is the EXT4_BOOT_LOADER_INO which is
4213 * not initialized on a new filesystem. */
4214 }
4223 #ifdef CONFIG_QUOTA
4225 #endif
4229 /*
4230 * NOTE! The in-memory inode i_data array is in little-endian order
4231 * even on big-endian machines: we do NOT byteswap the block numbers!
4232 */
4237 /*
4238 * Set transaction id's of transactions that have to be committed
4239 * to finish f[data]sync. We set them to currently running transaction
4240 * as we cannot be sure that the inode or some of its metadata isn't
4241 * part of the transaction - the inode could have been reclaimed and
4242 * now it is reread from disk.
4243 */
4246 tid_t tid;
4251 else
4255 else
4260 }
4264 /* The extra space is currently unused. Use it. */
4266 EXT4_GOOD_OLD_INODE_SIZE;
4269 }
4270 }
4283 }
4284 }
4298 /* Validate extent which is part of inode */
4303 /* Validate block references which are part of inode */
4305 }
4306 }
4326 }
4333 else
4342 }
4348 bad_inode:
4352 }
4355 {
4359 }
4364 {
4370 /*
4371 * i_blocks can be represented in a 32 bit variable
4372 * as multiple of 512 bytes
4373 */
4378 }
4383 /*
4384 * i_blocks can be represented in a 48 bit variable
4385 * as multiple of 512 bytes
4386 */
4392 /* i_block is stored in file system block size */
4396 }
4398 }
4403 };
4407 {
4432 }
4435 }
4437 /*
4438 * Opportunistically update the other time fields for other inodes in
4439 * the same inode table block.
4440 */
4443 {
4450 /*
4451 * Calculate the first inode in the inode table block. Inode
4452 * numbers are one-based. That is, the first inode in a block
4453 * (assuming 4k blocks and 256 byte inodes) is (n*16 + 1).
4454 */
4461 }
4462 }
4464 /*
4465 * Post the struct inode info into an on-disk inode location in the
4466 * buffer-cache. This gobbles the caller's reference to the
4467 * buffer_head in the inode location struct.
4468 *
4469 * The caller must have write access to iloc->bh.
4470 */
4474 {
4481 uid_t i_uid;
4482 gid_t i_gid;
4486 /* For fields not tracked in the in-memory inode,
4487 * initialise them to zero for new inodes. */
4498 /*
4499 * Fix up interoperability with old kernels. Otherwise, old inodes get
4500 * re-used with the upper 16 bits of the uid/gid intact
4501 */
4510 }
4516 }
4528 }
4538 }
4541 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4545 }
4557 }
4561 }
4571 }
4572 }
4591 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4594 }
4596 out_brelse:
4600 }
4602 /*
4603 * ext4_write_inode()
4604 *
4605 * We are called from a few places:
4606 *
4607 * - Within generic_file_aio_write() -> generic_write_sync() for O_SYNC files.
4608 * Here, there will be no transaction running. We wait for any running
4609 * transaction to commit.
4610 *
4611 * - Within flush work (sys_sync(), kupdate and such).
4612 * We wait on commit, if told to.
4613 *
4614 * - Within iput_final() -> write_inode_now()
4615 * We wait on commit, if told to.
4616 *
4617 * In all cases it is actually safe for us to return without doing anything,
4618 * because the inode has been copied into a raw inode buffer in
4619 * ext4_mark_inode_dirty(). This is a correctness thing for WB_SYNC_ALL
4620 * writeback.
4621 *
4622 * Note that we are absolutely dependent upon all inode dirtiers doing the
4623 * right thing: they *must* call mark_inode_dirty() after dirtying info in
4624 * which we are interested.
4625 *
4626 * It would be a bug for them to not do this. The code:
4627 *
4628 * mark_inode_dirty(inode)
4629 * stuff();
4630 * inode->i_size = expr;
4631 *
4632 * is in error because write_inode() could occur while `stuff()' is running,
4633 * and the new i_size will be lost. Plus the inode will no longer be on the
4634 * superblock's dirty inode list.
4635 */
4637 {
4648 }
4650 /*
4651 * No need to force transaction in WB_SYNC_NONE mode. Also
4652 * ext4_sync_fs() will force the commit after everything is
4653 * written.
4654 */
4665 /*
4666 * sync(2) will flush the whole buffer cache. No need to do
4667 * it here separately for each inode.
4668 */
4675 }
4677 }
4679 }
4681 /*
4682 * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
4683 * buffers that are attached to a page stradding i_size and are undergoing
4684 * commit. In that case we have to wait for commit to finish and try again.
4685 */
4687 {
4695 /*
4696 * All buffers in the last page remain valid? Then there's nothing to
4697 * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
4698 * blocksize case
4699 */
4720 }
4721 }
4723 /*
4724 * ext4_setattr()
4725 *
4726 * Called from notify_change.
4727 *
4728 * We want to trap VFS attempts to truncate the file as soon as
4729 * possible. In particular, we want to make sure that when the VFS
4730 * shrinks i_size, we put the inode on the orphan list and modify
4731 * i_disksize immediately, so that during the subsequent flushing of
4732 * dirty pages and freeing of disk blocks, we can guarantee that any
4733 * commit will leave the blocks being flushed in an unused state on
4734 * disk. (On recovery, the inode will get truncated and the blocks will
4735 * be freed, so we have a strong guarantee that no future commit will
4736 * leave these blocks visible to the user.)
4737 *
4738 * Another thing we have to assure is that if we are in ordered mode
4739 * and inode is still attached to the committing transaction, we must
4740 * we start writeout of all the dirty pages which are being truncated.
4741 * This way we are sure that all the data written in the previous
4742 * transaction are already on disk (truncate waits for pages under
4743 * writeback).
4744 *
4745 * Called with inode->i_mutex down.
4746 */
4748 {
4764 /* (user+group)*(old+new) structure, inode write (sb,
4765 * inode block, ? - but truncate inode update has it) */
4772 }
4777 }
4778 /* Update corresponding info in inode so that everything is in
4779 * one transaction */
4786 }
4796 }
4808 }
4813 }
4817 }
4823 /*
4824 * We have to update i_size under i_data_sem together
4825 * with i_disksize to avoid races with writeback code
4826 * running ext4_wb_update_i_disksize().
4827 */
4835 }
4841 }
4843 /*
4844 * Blocks are going to be removed from the inode. Wait
4845 * for dio in flight. Temporarily disable
4846 * dioread_nolock to prevent livelock.
4847 */
4855 }
4857 /*
4858 * Truncate pagecache after we've waited for commit
4859 * in data=journal mode to make pages freeable.
4860 */
4863 }
4864 /*
4865 * We want to call ext4_truncate() even if attr->ia_size ==
4866 * inode->i_size for cases like truncation of fallocated space
4867 */
4874 }
4876 /*
4877 * If the call to ext4_truncate failed to get a transaction handle at
4878 * all, we need to clean up the in-core orphan list manually.
4879 */
4886 err_out:
4891 }
4895 {
4902 /*
4903 * If there is inline data in the inode, the inode will normally not
4904 * have data blocks allocated (it may have an external xattr block).
4905 * Report at least one sector for such files, so tools like tar, rsync,
4906 * others doen't incorrectly think the file is completely sparse.
4907 */
4911 /*
4912 * We can't update i_blocks if the block allocation is delayed
4913 * otherwise in the case of system crash before the real block
4914 * allocation is done, we will have i_blocks inconsistent with
4915 * on-disk file blocks.
4916 * We always keep i_blocks updated together with real
4917 * allocation. But to not confuse with user, stat
4918 * will return the blocks that include the delayed allocation
4919 * blocks for this file.
4920 */
4925 }
4929 {
4933 }
4935 /*
4936 * Account for index blocks, block groups bitmaps and block group
4937 * descriptor blocks if modify datablocks and index blocks
4938 * worse case, the indexs blocks spread over different block groups
4939 *
4940 * If datablocks are discontiguous, they are possible to spread over
4941 * different block groups too. If they are contiguous, with flexbg,
4942 * they could still across block group boundary.
4943 *
4944 * Also account for superblock, inode, quota and xattr blocks
4945 */
4948 {
4954 /*
4955 * How many index blocks need to touch to map @lblocks logical blocks
4956 * to @pextents physical extents?
4957 */
4962 /*
4963 * Now let's see how many group bitmaps and group descriptors need
4964 * to account
4965 */
4973 /* bitmaps and block group descriptor blocks */
4976 /* Blocks for super block, inode, quota and xattr blocks */
4980 }
4982 /*
4983 * Calculate the total number of credits to reserve to fit
4984 * the modification of a single pages into a single transaction,
4985 * which may include multiple chunks of block allocations.
4986 *
4987 * This could be called via ext4_write_begin()
4988 *
4989 * We need to consider the worse case, when
4990 * one new block per extent.
4991 */
4993 {
4999 /* Account for data blocks for journalled mode */
5003 }
5005 /*
5006 * Calculate the journal credits for a chunk of data modification.
5007 *
5008 * This is called from DIO, fallocate or whoever calling
5009 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
5010 *
5011 * journal buffers for data blocks are not included here, as DIO
5012 * and fallocate do no need to journal data buffers.
5013 */
5015 {
5017 }
5019 /*
5020 * The caller must have previously called ext4_reserve_inode_write().
5021 * Give this, we know that the caller already has write access to iloc->bh.
5022 */
5025 {
5031 /* the do_update_inode consumes one bh->b_count */
5034 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
5038 }
5040 /*
5041 * On success, We end up with an outstanding reference count against
5042 * iloc->bh. This _must_ be cleaned up later.
5043 */
5045 int
5048 {
5058 }
5059 }
5062 }
5064 /*
5065 * Expand an inode by new_extra_isize bytes.
5066 * Returns 0 on success or negative error number on failure.
5067 */
5072 {
5083 /* No extended attributes present */
5087 new_extra_isize);
5090 }
5092 /* try to expand with EAs present */
5095 }
5097 /*
5098 * What we do here is to mark the in-core inode as clean with respect to inode
5099 * dirtiness (it may still be data-dirty).
5100 * This means that the in-core inode may be reaped by prune_icache
5101 * without having to perform any I/O. This is a very good thing,
5102 * because *any* task may call prune_icache - even ones which
5103 * have a transaction open against a different journal.
5104 *
5105 * Is this cheating? Not really. Sure, we haven't written the
5106 * inode out, but prune_icache isn't a user-visible syncing function.
5107 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
5108 * we start and wait on commits.
5109 */
5111 {
5125 /*
5126 * We need extra buffer credits since we may write into EA block
5127 * with this same handle. If journal_extend fails, then it will
5128 * only result in a minor loss of functionality for that inode.
5129 * If this is felt to be critical, then e2fsck should be run to
5130 * force a large enough s_min_extra_isize.
5131 */
5139 EXT4_STATE_NO_EXPAND);
5143 "Unable to expand inode %lu. Delete"
5146 mnt_count =
5148 }
5149 }
5150 }
5151 }
5153 }
5155 /*
5156 * ext4_dirty_inode() is called from __mark_inode_dirty()
5157 *
5158 * We're really interested in the case where a file is being extended.
5159 * i_size has been changed by generic_commit_write() and we thus need
5160 * to include the updated inode in the current transaction.
5161 *
5162 * Also, dquot_alloc_block() will always dirty the inode when blocks
5163 * are allocated to the file.
5164 *
5165 * If the inode is marked synchronous, we don't honour that here - doing
5166 * so would cause a commit on atime updates, which we don't bother doing.
5167 * We handle synchronous inodes at the highest possible level.
5168 *
5169 * If only the I_DIRTY_TIME flag is set, we can skip everything. If
5170 * I_DIRTY_TIME and I_DIRTY_SYNC is set, the only inode fields we need
5171 * to copy into the on-disk inode structure are the timestamp files.
5172 */
5174 {
5186 out:
5188 }
5190 #if 0
5191 /*
5192 * Bind an inode's backing buffer_head into this transaction, to prevent
5193 * it from being flushed to disk early. Unlike
5194 * ext4_reserve_inode_write, this leaves behind no bh reference and
5195 * returns no iloc structure, so the caller needs to repeat the iloc
5196 * lookup to mark the inode dirty later.
5197 */
5199 {
5210 NULL,
5213 }
5214 }
5217 }
5218 #endif
5221 {
5226 /*
5227 * We have to be very careful here: changing a data block's
5228 * journaling status dynamically is dangerous. If we write a
5229 * data block to the journal, change the status and then delete
5230 * that block, we risk forgetting to revoke the old log record
5231 * from the journal and so a subsequent replay can corrupt data.
5232 * So, first we make sure that the journal is empty and that
5233 * nobody is changing anything.
5234 */
5241 /* We have to allocate physical blocks for delalloc blocks
5242 * before flushing journal. otherwise delalloc blocks can not
5243 * be allocated any more. even more truncate on delalloc blocks
5244 * could trigger BUG by flushing delalloc blocks in journal.
5245 * There is no delalloc block in non-journal data mode.
5246 */
5251 }
5253 /* Wait for all existing dio workers */
5259 /*
5260 * OK, there are no updates running now, and all cached data is
5261 * synced to disk. We are now in a completely consistent state
5262 * which doesn't have anything in the journal, and we know that
5263 * no filesystem updates are running, so it is safe to modify
5264 * the inode's in-core data-journaling state flag now.
5265 */
5275 }
5277 }
5283 /* Finally we can mark the inode as dirty. */
5295 }
5298 {
5300 }
5303 {
5305 loff_t size;
5319 /* Delalloc case is easy... */
5325 ext4_da_get_block_prep);
5329 }
5333 /* Page got truncated from under us? */
5338 }
5342 else
5344 /*
5345 * Return if we have all the buffers mapped. This avoids the need to do
5346 * journal_start/journal_stop which can block and take a long time
5347 */
5351 ext4_bh_unmapped)) {
5352 /* Wait so that we don't change page under IO */
5356 }
5357 }
5359 /* OK, we need to fill the hole... */
5362 else
5364 retry_alloc:
5370 }
5379 }
5381 }
5385 out_ret:
5387 out:
5391 }
5394 {
5403 }