| blob | 5cb9a212b86f3efd69ca604df07dc20b901dabb1 |
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 {
94 else
98 }
102 {
103 __u32 csum;
115 }
118 loff_t new_size)
119 {
121 /*
122 * If jinode is zero, then we never opened the file for
123 * writing, so there's no need to call
124 * jbd2_journal_begin_ordered_truncate() since there's no
125 * outstanding writes we need to flush.
126 */
131 new_size);
132 }
141 /*
142 * Test whether an inode is a fast symlink.
143 */
145 {
153 }
155 /*
156 * Restart the transaction associated with *handle. This does a commit,
157 * so before we call here everything must be consistently dirtied against
158 * this transaction.
159 */
162 {
165 /*
166 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
167 * moment, get_block can be called only for blocks inside i_size since
168 * page cache has been already dropped and writes are blocked by
169 * i_mutex. So we can safely drop the i_data_sem here.
170 */
179 }
181 /*
182 * Called at the last iput() if i_nlink is zero.
183 */
185 {
192 /*
193 * When journalling data dirty buffers are tracked only in the
194 * journal. So although mm thinks everything is clean and
195 * ready for reaping the inode might still have some pages to
196 * write in the running transaction or waiting to be
197 * checkpointed. Thus calling jbd2_journal_invalidatepage()
198 * (via truncate_inode_pages()) to discard these buffers can
199 * cause data loss. Also even if we did not discard these
200 * buffers, we would have no way to find them after the inode
201 * is reaped and thus user could see stale data if he tries to
202 * read them before the transaction is checkpointed. So be
203 * careful and force everything to disk here... We use
204 * ei->i_datasync_tid to store the newest transaction
205 * containing inode's data.
206 *
207 * Note that directories do not have this problem because they
208 * don't use page cache.
209 */
218 }
223 }
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 * Called with i_data_sem down, which is important since we can call
326 * ext4_discard_preallocations() from here.
327 */
330 {
343 }
345 /* Update per-inode reservations */
351 /* Update quota subsystem for data blocks */
355 /*
356 * We did fallocate with an offset that is already delayed
357 * allocated. So on delayed allocated writeback we should
358 * not re-claim the quota for fallocated blocks.
359 */
361 }
363 /*
364 * If we have done all the pending block allocations and if
365 * there aren't any writers on the inode, we can discard the
366 * inode's preallocations.
367 */
371 }
376 {
380 "lblock %lu mapped to illegal pblock "
384 }
386 }
388 #define check_block_validity(inode, map) \
389 __check_block_validity((inode), __func__, __LINE__, (map))
391 #ifdef ES_AGGRESSIVE_TEST
397 {
401 /*
402 * There is a race window that the result is not the same.
403 * e.g. xfstests #223 when dioread_nolock enables. The reason
404 * is that we lookup a block mapping in extent status tree with
405 * out taking i_data_sem. So at the time the unwritten extent
406 * could be converted.
407 */
412 EXT4_GET_BLOCKS_KEEP_SIZE);
415 EXT4_GET_BLOCKS_KEEP_SIZE);
416 }
420 /*
421 * We don't check m_len because extent will be collpased in status
422 * tree. So the m_len might not equal.
423 */
428 "es_cached ex [%d/%d/%llu/%x] != "
434 }
435 }
438 /*
439 * The ext4_map_blocks() function tries to look up the requested blocks,
440 * and returns if the blocks are already mapped.
441 *
442 * Otherwise it takes the write lock of the i_data_sem and allocate blocks
443 * and store the allocated blocks in the result buffer head and mark it
444 * mapped.
445 *
446 * If file type is extents based, it will call ext4_ext_map_blocks(),
447 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
448 * based files
449 *
450 * On success, it returns the number of blocks being mapped or allocated.
451 * if create==0 and the blocks are pre-allocated and unwritten block,
452 * the result buffer head is unmapped. If the create ==1, it will make sure
453 * the buffer head is mapped.
454 *
455 * It returns 0 if plain look up failed (blocks have not been allocated), in
456 * that case, buffer head is unmapped
457 *
458 * It returns the error in case of allocation failure.
459 */
462 {
466 #ifdef ES_AGGRESSIVE_TEST
470 #endif
477 /*
478 * ext4_map_blocks returns an int, and m_len is an unsigned int
479 */
483 /* We can handle the block number less than EXT_MAX_BLOCKS */
487 /* Lookup extent status tree firstly */
502 }
503 #ifdef ES_AGGRESSIVE_TEST
506 #endif
508 }
510 /*
511 * Try to see if we can get the block without requesting a new
512 * file system block.
513 */
518 EXT4_GET_BLOCKS_KEEP_SIZE);
521 EXT4_GET_BLOCKS_KEEP_SIZE);
522 }
528 "ES len assertion failed for inode "
532 }
544 }
548 found:
553 }
555 /* If it is only a block(s) look up */
559 /*
560 * Returns if the blocks have already allocated
561 *
562 * Note that if blocks have been preallocated
563 * ext4_ext_get_block() returns the create = 0
564 * with buffer head unmapped.
565 */
567 /*
568 * If we need to convert extent to unwritten
569 * we continue and do the actual work in
570 * ext4_ext_map_blocks()
571 */
575 /*
576 * Here we clear m_flags because after allocating an new extent,
577 * it will be set again.
578 */
581 /*
582 * New blocks allocate and/or writing to unwritten extent
583 * will possibly result in updating i_data, so we take
584 * the write lock of i_data_sem, and call get_block()
585 * with create == 1 flag.
586 */
589 /*
590 * We need to check for EXT4 here because migrate
591 * could have changed the inode type in between
592 */
599 /*
600 * We allocated new blocks which will result in
601 * i_data's format changing. Force the migrate
602 * to fail by clearing migrate flags
603 */
605 }
607 /*
608 * Update reserved blocks/metadata blocks after successful
609 * block allocation which had been deferred till now. We don't
610 * support fallocate for non extent files. So we can update
611 * reserve space here.
612 */
616 }
623 "ES len assertion failed for inode "
627 }
629 /*
630 * If the extent has been zeroed out, we don't need to update
631 * extent status tree.
632 */
637 }
648 }
650 has_zeroout:
656 }
658 }
661 {
663 /* XXX: breaks on 32-bit > 16GB. Is that even supported? */
670 }
672 /* Maximum number of blocks we map for direct IO at once. */
673 #define DIO_MAX_BLOCKS 4096
677 {
690 /* Direct IO write... */
695 dio_credits);
699 }
701 }
713 }
718 }
722 }
726 {
729 }
731 /*
732 * `handle' can be NULL if create is zero
733 */
736 {
760 /*
761 * Now that we do not always journal data, we should
762 * keep in mind whether this should always journal the
763 * new buffer as metadata. For now, regular file
764 * writes use ext4_get_block instead, so it's not a
765 * problem.
766 */
773 }
777 }
786 errout:
789 }
793 {
807 }
816 {
832 }
836 }
838 }
840 /*
841 * To preserve ordering, it is essential that the hole instantiation and
842 * the data write be encapsulated in a single transaction. We cannot
843 * close off a transaction and start a new one between the ext4_get_block()
844 * and the commit_write(). So doing the jbd2_journal_start at the start of
845 * prepare_write() is the right place.
846 *
847 * Also, this function can nest inside ext4_writepage(). In that case, we
848 * *know* that ext4_writepage() has generated enough buffer credits to do the
849 * whole page. So we won't block on the journal in that case, which is good,
850 * because the caller may be PF_MEMALLOC.
851 *
852 * By accident, ext4 can be reentered when a transaction is open via
853 * quota file writes. If we were to commit the transaction while thus
854 * reentered, there can be a deadlock - we would be holding a quota
855 * lock, and the commit would never complete if another thread had a
856 * transaction open and was blocking on the quota lock - a ranking
857 * violation.
858 *
859 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
860 * will _not_ run commit under these circumstances because handle->h_ref
861 * is elevated. We'll still have enough credits for the tiny quotafile
862 * write.
863 */
866 {
872 /*
873 * __block_write_begin() could have dirtied some buffers. Clean
874 * the dirty bit as jbd2_journal_get_write_access() could complain
875 * otherwise about fs integrity issues. Setting of the dirty bit
876 * by __block_write_begin() isn't a real problem here as we clear
877 * the bit before releasing a page lock and thus writeback cannot
878 * ever write the buffer.
879 */
887 }
894 {
900 pgoff_t index;
904 /*
905 * Reserve one block more for addition to orphan list in case
906 * we allocate blocks but write fails for some reason
907 */
920 }
922 /*
923 * grab_cache_page_write_begin() can take a long time if the
924 * system is thrashing due to memory pressure, or if the page
925 * is being written back. So grab it first before we start
926 * the transaction handle. This also allows us to allocate
927 * the page (if needed) without using GFP_NOFS.
928 */
929 retry_grab:
935 retry_journal:
940 }
944 /* The page got truncated from under us */
949 }
950 /* In case writeback began while the page was unlocked */
955 else
961 do_journal_get_write_access);
962 }
966 /*
967 * __block_write_begin may have instantiated a few blocks
968 * outside i_size. Trim these off again. Don't need
969 * i_size_read because we hold i_mutex.
970 *
971 * Add inode to orphan list in case we crash before
972 * truncate finishes
973 */
980 /*
981 * If truncate failed early the inode might
982 * still be on the orphan list; we need to
983 * make sure the inode is removed from the
984 * orphan list in that case.
985 */
988 }
995 }
998 }
1000 /* For write_end() in data=journal mode */
1002 {
1011 }
1013 /*
1014 * We need to pick up the new inode size which generic_commit_write gave us
1015 * `file' can be NULL - eg, when called from page_symlink().
1016 *
1017 * ext4 never places buffers on inode->i_mapping->private_list. metadata
1018 * buffers are managed internally.
1019 */
1024 {
1038 }
1039 }
1050 /*
1051 * it's important to update i_size while still holding page lock:
1052 * page writeout could otherwise come in and zero beyond i_size.
1053 */
1060 /*
1061 * Don't mark the inode dirty under page lock. First, it unnecessarily
1062 * makes the holding time of page lock longer. Second, it forces lock
1063 * ordering of page lock and transaction start for journaling
1064 * filesystems.
1065 */
1070 /* if we have allocated more blocks and copied
1071 * less. We will have blocks allocated outside
1072 * inode->i_size. So truncate them
1073 */
1075 errout:
1082 /*
1083 * If truncate failed early the inode might still be
1084 * on the orphan list; we need to make sure the inode
1085 * is removed from the orphan list in that case.
1086 */
1089 }
1092 }
1098 {
1121 }
1127 }
1141 }
1144 /* if we have allocated more blocks and copied
1145 * less. We will have blocks allocated outside
1146 * inode->i_size. So truncate them
1147 */
1155 /*
1156 * If truncate failed early the inode might still be
1157 * on the orphan list; we need to make sure the inode
1158 * is removed from the orphan list in that case.
1159 */
1162 }
1165 }
1167 /*
1168 * Reserve a single cluster located at lblock
1169 */
1171 {
1177 /*
1178 * We will charge metadata quota at writeout time; this saves
1179 * us from metadata over-estimation, though we may go over by
1180 * a small amount in the end. Here we just reserve for data.
1181 */
1186 /*
1187 * recalculate the amount of metadata blocks to reserve
1188 * in order to allocate nrblocks
1189 * worse case is one extent per block
1190 */
1192 /*
1193 * ext4_calc_metadata_amount() has side effects, which we have
1194 * to be prepared undo if we fail to claim space.
1195 */
1203 }
1208 }
1211 {
1222 /*
1223 * if there aren't enough reserved blocks, then the
1224 * counter is messed up somewhere. Since this
1225 * function is called from invalidate page, it's
1226 * harmless to return without any action.
1227 */
1229 "ino %lu, to_free %d with only %d reserved "
1234 }
1237 /* update fs dirty data blocks counter */
1243 }
1248 {
1256 ext4_fsblk_t lblk;
1269 to_release++;
1271 }
1278 }
1280 /* If we have released all the blocks belonging to a cluster, then we
1281 * need to release the reserved space for that cluster. */
1290 num_clusters--;
1291 }
1292 }
1294 /*
1295 * Delayed allocation stuff
1296 */
1305 /*
1306 * Extent to map - this can be after first_page because that can be
1307 * fully mapped. We somewhat abuse m_flags to store whether the extent
1308 * is delalloc or unwritten.
1309 */
1312 };
1316 {
1323 /* This is necessary when next_page == 0. */
1334 }
1350 }
1352 }
1355 }
1356 }
1359 {
1378 }
1381 {
1383 }
1385 /*
1386 * This function is grabs code from the very beginning of
1387 * ext4_map_blocks, but assumes that the caller is from delayed write
1388 * time. This function looks up the requested blocks and sets the
1389 * buffer delay bit under the protection of i_data_sem.
1390 */
1394 {
1398 #ifdef ES_AGGRESSIVE_TEST
1402 #endif
1412 /* Lookup extent status tree firstly */
1418 }
1420 /*
1421 * Delayed extent could be allocated by fallocate.
1422 * So we need to check it.
1423 */
1429 }
1440 else
1443 #ifdef ES_AGGRESSIVE_TEST
1445 #endif
1447 }
1449 /*
1450 * Try to see if we can get the block without requesting a new
1451 * file system block.
1452 */
1458 else
1461 add_delayed:
1464 /*
1465 * XXX: __block_prepare_write() unmaps passed block,
1466 * is it OK?
1467 */
1468 /*
1469 * If the block was allocated from previously allocated cluster,
1470 * then we don't need to reserve it again. However we still need
1471 * to reserve metadata for every block we're going to write.
1472 */
1477 /* not enough space to reserve */
1480 }
1481 }
1488 }
1499 "ES len assertion failed for inode "
1503 }
1511 }
1513 out_unlock:
1517 }
1519 /*
1520 * This is a special get_block_t callback which is used by
1521 * ext4_da_write_begin(). It will either return mapped block or
1522 * reserve space for a single block.
1523 *
1524 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
1525 * We also have b_blocknr = -1 and b_bdev initialized properly
1526 *
1527 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
1528 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
1529 * initialized properly.
1530 */
1533 {
1543 /*
1544 * first, we need to know whether the block is allocated already
1545 * preallocated blocks are unmapped but should treated
1546 * the same as allocated blocks.
1547 */
1556 /* A delayed write to unwritten bh should be marked
1557 * new and mapped. Mapped ensures that we don't do
1558 * get_block multiple times when we write to the same
1559 * offset and new ensures that we do proper zero out
1560 * for partial write.
1561 */
1564 }
1566 }
1569 {
1572 }
1575 {
1578 }
1582 {
1604 }
1607 }
1608 /* As soon as we unlock the page, it can go away, but we have
1609 * references to buffers so we are safe */
1617 }
1629 do_journal_get_write_access);
1632 write_end_fn);
1633 }
1645 out:
1648 }
1650 /*
1651 * Note that we don't need to start a transaction unless we're journaling data
1652 * because we should have holes filled from ext4_page_mkwrite(). We even don't
1653 * need to file the inode to the transaction's list in ordered mode because if
1654 * we are writing back data added by write(), the inode is already there and if
1655 * we are writing back data modified via mmap(), no one guarantees in which
1656 * transaction the data will hit the disk. In case we are journaling data, we
1657 * cannot start transaction directly because transaction start ranks above page
1658 * lock so we have to do some magic.
1659 *
1660 * This function can get called via...
1661 * - ext4_writepages after taking page lock (have journal handle)
1662 * - journal_submit_inode_data_buffers (no journal handle)
1663 * - shrink_page_list via the kswapd/direct reclaim (no journal handle)
1664 * - grab_page_cache when doing write_begin (have journal handle)
1665 *
1666 * We don't do any block allocation in this function. If we have page with
1667 * multiple blocks we need to write those buffer_heads that are mapped. This
1668 * is important for mmaped based write. So if we do with blocksize 1K
1669 * truncate(f, 1024);
1670 * a = mmap(f, 0, 4096);
1671 * a[0] = 'a';
1672 * truncate(f, 4096);
1673 * we have in the page first buffer_head mapped via page_mkwrite call back
1674 * but other buffer_heads would be unmapped but dirty (dirty done via the
1675 * do_wp_page). So writepage should write the first block. If we modify
1676 * the mmap area beyond 1024 we will again get a page_fault and the
1677 * page_mkwrite callback will do the block allocation and mark the
1678 * buffer_heads mapped.
1679 *
1680 * We redirty the page if we have any buffer_heads that is either delay or
1681 * unwritten in the page.
1682 *
1683 * We can get recursively called as show below.
1684 *
1685 * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1686 * ext4_writepage()
1687 *
1688 * But since we don't do any block allocation we should not deadlock.
1689 * Page also have the dirty flag cleared so we don't get recurive page_lock.
1690 */
1693 {
1695 loff_t size;
1706 else
1710 /*
1711 * We cannot do block allocation or other extent handling in this
1712 * function. If there are buffers needing that, we have to redirty
1713 * the page. But we may reach here when we do a journal commit via
1714 * journal_submit_inode_data_buffers() and in that case we must write
1715 * allocated buffers to achieve data=ordered mode guarantees.
1716 */
1718 ext4_bh_delay_or_unwritten)) {
1721 /*
1722 * For memory cleaning there's no point in writing only
1723 * some buffers. So just bail out. Warn if we came here
1724 * from direct reclaim.
1725 */
1730 }
1732 }
1735 /*
1736 * It's mmapped pagecache. Add buffers and journal it. There
1737 * doesn't seem much point in redirtying the page here.
1738 */
1747 }
1750 /* Drop io_end reference we got from init */
1753 }
1756 {
1764 else
1773 }
1775 #define BH_FLAGS ((1 << BH_Unwritten) | (1 << BH_Delay))
1777 /*
1778 * mballoc gives us at most this number of blocks...
1779 * XXX: That seems to be only a limitation of ext4_mb_normalize_request().
1780 * The rest of mballoc seems to handle chunks up to full group size.
1781 */
1782 #define MAX_WRITEPAGES_EXTENT_LEN 2048
1784 /*
1785 * mpage_add_bh_to_extent - try to add bh to extent of blocks to map
1786 *
1787 * @mpd - extent of blocks
1788 * @lblk - logical number of the block in the file
1789 * @bh - buffer head we want to add to the extent
1790 *
1791 * The function is used to collect contig. blocks in the same state. If the
1792 * buffer doesn't require mapping for writeback and we haven't started the
1793 * extent of buffers to map yet, the function returns 'true' immediately - the
1794 * caller can write the buffer right away. Otherwise the function returns true
1795 * if the block has been added to the extent, false if the block couldn't be
1796 * added.
1797 */
1800 {
1803 /* Buffer that doesn't need mapping for writeback? */
1806 /* So far no extent to map => we write the buffer right away */
1810 }
1812 /* First block in the extent? */
1818 }
1820 /* Don't go larger than mballoc is willing to allocate */
1824 /* Can we merge the block to our big extent? */
1829 }
1831 }
1833 /*
1834 * mpage_process_page_bufs - submit page buffers for IO or add them to extent
1835 *
1836 * @mpd - extent of blocks for mapping
1837 * @head - the first buffer in the page
1838 * @bh - buffer we should start processing from
1839 * @lblk - logical number of the block in the file corresponding to @bh
1840 *
1841 * Walk through page buffers from @bh upto @head (exclusive) and either submit
1842 * the page for IO if all buffers in this page were mapped and there's no
1843 * accumulated extent of buffers to map or add buffers in the page to the
1844 * extent of buffers to map. The function returns 1 if the caller can continue
1845 * by processing the next page, 0 if it should stop adding buffers to the
1846 * extent to map because we cannot extend it anymore. It can also return value
1847 * < 0 in case of error during IO submission.
1848 */
1852 ext4_lblk_t lblk)
1853 {
1863 /* Found extent to map? */
1866 /* Everything mapped so far and we hit EOF */
1868 }
1870 /* So far everything mapped? Submit the page for IO. */
1875 }
1877 }
1879 /*
1880 * mpage_map_buffers - update buffers corresponding to changed extent and
1881 * submit fully mapped pages for IO
1882 *
1883 * @mpd - description of extent to map, on return next extent to map
1884 *
1885 * Scan buffers corresponding to changed extent (we expect corresponding pages
1886 * to be already locked) and update buffer state according to new extent state.
1887 * We map delalloc buffers to their physical location, clear unwritten bits,
1888 * and mark buffers as uninit when we perform writes to unwritten extents
1889 * and do extent conversion after IO is finished. If the last page is not fully
1890 * mapped, we update @map to the next extent in the last page that needs
1891 * mapping. Otherwise we submit the page for IO.
1892 */
1894 {
1901 ext4_lblk_t lblk;
1902 sector_t pblock;
1913 PAGEVEC_SIZE);
1921 /* Up to 'end' pages must be contiguous */
1928 /*
1929 * Buffer after end of mapped extent.
1930 * Find next buffer in the page to map.
1931 */
1934 /*
1935 * FIXME: If dioread_nolock supports
1936 * blocksize < pagesize, we need to make
1937 * sure we add size mapped so far to
1938 * io_end->size as the following call
1939 * can submit the page for IO.
1940 */
1947 }
1951 }
1955 /*
1956 * FIXME: This is going to break if dioread_nolock
1957 * supports blocksize < pagesize as we will try to
1958 * convert potentially unmapped parts of inode.
1959 */
1961 /* Page fully mapped - let IO run! */
1966 }
1967 start++;
1968 }
1970 }
1971 /* Extent fully mapped and matches with page boundary. We are done. */
1975 }
1978 {
1985 /*
1986 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
1987 * to convert an unwritten extent to be initialized (in the case
1988 * where we have written into one or more preallocated blocks). It is
1989 * possible that we're going to need more metadata blocks than
1990 * previously reserved. However we must not fail because we're in
1991 * writeback and there is nothing we can do about it so it might result
1992 * in data loss. So use reserved blocks to allocate metadata if
1993 * possible.
1994 *
1995 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE if
1996 * the blocks in question are delalloc blocks. This indicates
1997 * that the blocks and quotas has already been checked when
1998 * the data was copied into the page cache.
1999 */
2001 EXT4_GET_BLOCKS_METADATA_NOFAIL;
2016 }
2018 }
2027 }
2029 }
2031 /*
2032 * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length
2033 * mpd->len and submit pages underlying it for IO
2034 *
2035 * @handle - handle for journal operations
2036 * @mpd - extent to map
2037 * @give_up_on_write - we set this to true iff there is a fatal error and there
2038 * is no hope of writing the data. The caller should discard
2039 * dirty pages to avoid infinite loops.
2040 *
2041 * The function maps extent starting at mpd->lblk of length mpd->len. If it is
2042 * delayed, blocks are allocated, if it is unwritten, we may need to convert
2043 * them to initialized or split the described range from larger unwritten
2044 * extent. Note that we need not map all the described range since allocation
2045 * can return less blocks or the range is covered by more unwritten extents. We
2046 * cannot map more because we are limited by reserved transaction credits. On
2047 * the other hand we always make sure that the last touched page is fully
2048 * mapped so that it can be written out (and thus forward progress is
2049 * guaranteed). After mapping we submit all mapped pages for IO.
2050 */
2054 {
2058 loff_t disksize;
2070 /*
2071 * Let the uper layers retry transient errors.
2072 * In the case of ENOSPC, if ext4_count_free_blocks()
2073 * is non-zero, a commit should free up blocks.
2074 */
2080 }
2082 "Delayed block allocation failed for "
2083 "inode %lu at logical offset %llu with"
2089 "This should not happen!! Data will "
2093 invalidate_dirty_pages:
2096 }
2098 /*
2099 * Update buffer state, submit mapped pages, and get us new
2100 * extent to map
2101 */
2107 update_disksize:
2108 /*
2109 * Update on-disk size after IO is submitted. Races with
2110 * truncate are avoided by checking i_size under i_data_sem.
2111 */
2115 loff_t i_size;
2131 }
2133 }
2135 /*
2136 * Calculate the total number of credits to reserve for one writepages
2137 * iteration. This is called from ext4_writepages(). We map an extent of
2138 * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
2139 * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN +
2140 * bpp - 1 blocks in bpp different extents.
2141 */
2143 {
2148 }
2150 /*
2151 * mpage_prepare_extent_to_map - find & lock contiguous range of dirty pages
2152 * and underlying extent to map
2153 *
2154 * @mpd - where to look for pages
2155 *
2156 * Walk dirty pages in the mapping. If they are fully mapped, submit them for
2157 * IO immediately. When we find a page which isn't mapped we start accumulating
2158 * extent of buffers underlying these pages that needs mapping (formed by
2159 * either delayed or unwritten buffers). We also lock the pages containing
2160 * these buffers. The extent found is returned in @mpd structure (starting at
2161 * mpd->lblk with length mpd->len blocks).
2162 *
2163 * Note that this function can attach bios to one io_end structure which are
2164 * neither logically nor physically contiguous. Although it may seem as an
2165 * unnecessary complication, it is actually inevitable in blocksize < pagesize
2166 * case as we need to track IO to all buffers underlying a page in one io_end.
2167 */
2169 {
2179 ext4_lblk_t lblk;
2184 else
2199 /*
2200 * At this point, the page may be truncated or
2201 * invalidated (changing page->mapping to NULL), or
2202 * even swizzled back from swapper_space to tmpfs file
2203 * mapping. However, page->index will not change
2204 * because we have a reference on the page.
2205 */
2209 /*
2210 * Accumulated enough dirty pages? This doesn't apply
2211 * to WB_SYNC_ALL mode. For integrity sync we have to
2212 * keep going because someone may be concurrently
2213 * dirtying pages, and we might have synced a lot of
2214 * newly appeared dirty pages, but have not synced all
2215 * of the old dirty pages.
2216 */
2220 /* If we can't merge this page, we are done. */
2225 /*
2226 * If the page is no longer dirty, or its mapping no
2227 * longer corresponds to inode we are writing (which
2228 * means it has been truncated or invalidated), or the
2229 * page is already under writeback and we are not doing
2230 * a data integrity writeback, skip the page
2231 */
2238 }
2246 /* Add all dirty buffers to mpd */
2254 left--;
2255 }
2258 }
2260 out:
2263 }
2267 {
2272 }
2276 {
2292 /*
2293 * No pages to write? This is mainly a kludge to avoid starting
2294 * a transaction for special inodes like journal inode on last iput()
2295 * because that could violate lock ordering on umount
2296 */
2307 }
2309 /*
2310 * If the filesystem has aborted, it is read-only, so return
2311 * right away instead of dumping stack traces later on that
2312 * will obscure the real source of the problem. We test
2313 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2314 * the latter could be true if the filesystem is mounted
2315 * read-only, and in that case, ext4_writepages should
2316 * *never* be called, so if that ever happens, we would want
2317 * the stack trace.
2318 */
2322 }
2325 /*
2326 * We may need to convert up to one extent per block in
2327 * the page and we may dirty the inode.
2328 */
2330 }
2332 /*
2333 * If we have inline data and arrive here, it means that
2334 * we will soon create the block for the 1st page, so
2335 * we'd better clear the inline data here.
2336 */
2338 /* Just inode will be modified... */
2343 }
2345 EXT4_STATE_MAY_INLINE_DATA));
2348 }
2362 }
2367 retry:
2373 /* For each extent of pages we use new io_end */
2378 }
2380 /*
2381 * We have two constraints: We find one extent to map and we
2382 * must always write out whole page (makes a difference when
2383 * blocksize < pagesize) so that we don't block on IO when we
2384 * try to write out the rest of the page. Journalled mode is
2385 * not supported by delalloc.
2386 */
2390 /* start a new transaction */
2398 /* Release allocated io_end */
2401 }
2410 /*
2411 * We scanned the whole range (or exhausted
2412 * nr_to_write), submitted what was mapped and
2413 * didn't find anything needing mapping. We are
2414 * done.
2415 */
2417 }
2418 }
2420 /* Submit prepared bio */
2422 /* Unlock pages we didn't use */
2424 /* Drop our io_end reference we got from init */
2428 /*
2429 * Commit the transaction which would
2430 * free blocks released in the transaction
2431 * and try again
2432 */
2436 }
2437 /* Fatal error - ENOMEM, EIO... */
2440 }
2447 }
2449 /* Update index */
2451 /*
2452 * Set the writeback_index so that range_cyclic
2453 * mode will write it back later
2454 */
2457 out_writepages:
2461 }
2464 {
2468 /*
2469 * switch to non delalloc mode if we are running low
2470 * on free block. The free block accounting via percpu
2471 * counters can get slightly wrong with percpu_counter_batch getting
2472 * accumulated on each CPU without updating global counters
2473 * Delalloc need an accurate free block accounting. So switch
2474 * to non delalloc when we are near to error range.
2475 */
2476 free_clusters =
2478 dirty_clusters =
2480 /*
2481 * Start pushing delalloc when 1/2 of free blocks are dirty.
2482 */
2488 /*
2489 * free block count is less than 150% of dirty blocks
2490 * or free blocks is less than watermark
2491 */
2493 }
2495 }
2497 /* We always reserve for an inode update; the superblock could be there too */
2499 {
2501 EXT4_FEATURE_RO_COMPAT_LARGE_FILE)))
2507 /* We might need to update the superblock to set LARGE_FILE */
2509 }
2514 {
2517 pgoff_t index;
2527 }
2539 }
2541 /*
2542 * grab_cache_page_write_begin() can take a long time if the
2543 * system is thrashing due to memory pressure, or if the page
2544 * is being written back. So grab it first before we start
2545 * the transaction handle. This also allows us to allocate
2546 * the page (if needed) without using GFP_NOFS.
2547 */
2548 retry_grab:
2554 /*
2555 * With delayed allocation, we don't log the i_disksize update
2556 * if there is delayed block allocation. But we still need
2557 * to journalling the i_disksize update if writes to the end
2558 * of file which has an already mapped buffer.
2559 */
2560 retry_journal:
2566 }
2570 /* The page got truncated from under us */
2575 }
2576 /* In case writeback began while the page was unlocked */
2583 /*
2584 * block_write_begin may have instantiated a few blocks
2585 * outside i_size. Trim these off again. Don't need
2586 * i_size_read because we hold i_mutex.
2587 */
2597 }
2601 }
2603 /*
2604 * Check if we should update i_disksize
2605 * when write to the end of file but not require block allocation
2606 */
2609 {
2624 }
2630 {
2634 loff_t new_i_size;
2646 /*
2647 * generic_write_end() will run mark_inode_dirty() if i_size
2648 * changes. So let's piggyback the i_disksize mark_inode_dirty
2649 * into that.
2650 */
2656 /* We need to mark inode dirty even if
2657 * new_i_size is less that inode->i_size
2658 * bu greater than i_disksize.(hint delalloc)
2659 */
2661 }
2662 }
2668 page);
2669 else
2681 }
2685 {
2686 /*
2687 * Drop reserved blocks
2688 */
2695 out:
2699 }
2701 /*
2702 * Force all delayed allocation blocks to be allocated for a given inode.
2703 */
2705 {
2711 /*
2712 * We do something simple for now. The filemap_flush() will
2713 * also start triggering a write of the data blocks, which is
2714 * not strictly speaking necessary (and for users of
2715 * laptop_mode, not even desirable). However, to do otherwise
2716 * would require replicating code paths in:
2717 *
2718 * ext4_writepages() ->
2719 * write_cache_pages() ---> (via passed in callback function)
2720 * __mpage_da_writepage() -->
2721 * mpage_add_bh_to_extent()
2722 * mpage_da_map_blocks()
2723 *
2724 * The problem is that write_cache_pages(), located in
2725 * mm/page-writeback.c, marks pages clean in preparation for
2726 * doing I/O, which is not desirable if we're not planning on
2727 * doing I/O at all.
2728 *
2729 * We could call write_cache_pages(), and then redirty all of
2730 * the pages by calling redirty_page_for_writepage() but that
2731 * would be ugly in the extreme. So instead we would need to
2732 * replicate parts of the code in the above functions,
2733 * simplifying them because we wouldn't actually intend to
2734 * write out the pages, but rather only collect contiguous
2735 * logical block extents, call the multi-block allocator, and
2736 * then update the buffer heads with the block allocations.
2737 *
2738 * For now, though, we'll cheat by calling filemap_flush(),
2739 * which will map the blocks, and start the I/O, but not
2740 * actually wait for the I/O to complete.
2741 */
2743 }
2745 /*
2746 * bmap() is special. It gets used by applications such as lilo and by
2747 * the swapper to find the on-disk block of a specific piece of data.
2748 *
2749 * Naturally, this is dangerous if the block concerned is still in the
2750 * journal. If somebody makes a swapfile on an ext4 data-journaling
2751 * filesystem and enables swap, then they may get a nasty shock when the
2752 * data getting swapped to that swapfile suddenly gets overwritten by
2753 * the original zero's written out previously to the journal and
2754 * awaiting writeback in the kernel's buffer cache.
2755 *
2756 * So, if we see any bmap calls here on a modified, data-journaled file,
2757 * take extra steps to flush any blocks which might be in the cache.
2758 */
2760 {
2765 /*
2766 * We can get here for an inline file via the FIBMAP ioctl
2767 */
2773 /*
2774 * With delalloc we want to sync the file
2775 * so that we can make sure we allocate
2776 * blocks for file
2777 */
2779 }
2783 /*
2784 * This is a REALLY heavyweight approach, but the use of
2785 * bmap on dirty files is expected to be extremely rare:
2786 * only if we run lilo or swapon on a freshly made file
2787 * do we expect this to happen.
2788 *
2789 * (bmap requires CAP_SYS_RAWIO so this does not
2790 * represent an unprivileged user DOS attack --- we'd be
2791 * in trouble if mortal users could trigger this path at
2792 * will.)
2793 *
2794 * NB. EXT4_STATE_JDATA is not set on files other than
2795 * regular files. If somebody wants to bmap a directory
2796 * or symlink and gets confused because the buffer
2797 * hasn't yet been flushed to disk, they deserve
2798 * everything they get.
2799 */
2809 }
2812 }
2815 {
2828 }
2830 static int
2833 {
2836 /* If the file has inline data, no need to do readpages. */
2841 }
2845 {
2848 /* No journalling happens on data buffers when this function is used */
2852 }
2857 {
2862 /*
2863 * If it's a full truncate we just forget about the pending dirtying
2864 */
2869 }
2871 /* Wrapper for aops... */
2875 {
2877 }
2880 {
2885 /* Page has dirty journalled data -> cannot release */
2890 else
2892 }
2894 /*
2895 * ext4_get_block used when preparing for a DIO write or buffer write.
2896 * We allocate an uinitialized extent if blocks haven't been allocated.
2897 * The extent will be converted to initialized after the IO is complete.
2898 */
2901 {
2905 EXT4_GET_BLOCKS_IO_CREATE_EXT);
2906 }
2910 {
2914 EXT4_GET_BLOCKS_NO_LOCK);
2915 }
2919 {
2922 /* if not async direct IO just return */
2929 size);
2935 }
2937 /*
2938 * For ext4 extent files, ext4 will do direct-io write to holes,
2939 * preallocated extents, and those write extend the file, no need to
2940 * fall back to buffered IO.
2941 *
2942 * For holes, we fallocate those blocks, mark them as unwritten
2943 * If those blocks were preallocated, we mark sure they are split, but
2944 * still keep the range to write as unwritten.
2945 *
2946 * The unwritten extents will be converted to written when DIO is completed.
2947 * For async direct IO, since the IO may still pending when return, we
2948 * set up an end_io call back function, which will do the conversion
2949 * when async direct IO completed.
2950 *
2951 * If the O_DIRECT write will extend the file then add this inode to the
2952 * orphan list. So recovery will truncate it back to the original size
2953 * if the machine crashes during the write.
2954 *
2955 */
2958 {
2961 ssize_t ret;
2969 /* Use the old path for reads and writes beyond i_size. */
2975 /*
2976 * Make all waiters for direct IO properly wait also for extent
2977 * conversion. This also disallows race between truncate() and
2978 * overwrite DIO as i_dio_count needs to be incremented under i_mutex.
2979 */
2983 /* If we do a overwrite dio, i_mutex locking can be released */
2989 }
2991 /*
2992 * We could direct write to holes and fallocate.
2993 *
2994 * Allocated blocks to fill the hole are marked as
2995 * unwritten to prevent parallel buffered read to expose
2996 * the stale data before DIO complete the data IO.
2997 *
2998 * As to previously fallocated extents, ext4 get_block will
2999 * just simply mark the buffer mapped but still keep the
3000 * extents unwritten.
3001 *
3002 * For non AIO case, we will convert those unwritten extents
3003 * to written after return back from blockdev_direct_IO.
3004 *
3005 * For async DIO, the conversion needs to be deferred when the
3006 * IO is completed. The ext4 end_io callback function will be
3007 * called to take care of the conversion work. Here for async
3008 * case, we allocate an io_end structure to hook to the iocb.
3009 */
3017 }
3018 /*
3019 * Grab reference for DIO. Will be dropped in ext4_end_io_dio()
3020 */
3022 /*
3023 * we save the io structure for current async direct
3024 * IO, so that later ext4_map_blocks() could flag the
3025 * io structure whether there is a unwritten extents
3026 * needs to be converted when IO is completed.
3027 */
3029 }
3036 }
3040 else
3043 get_block_func,
3046 /*
3047 * Put our reference to io_end. This can free the io_end structure e.g.
3048 * in sync IO case or in case of error. It can even perform extent
3049 * conversion if all bios we submitted finished before we got here.
3050 * Note that in that case iocb->private can be already set to NULL
3051 * here.
3052 */
3056 /*
3057 * When no IO was submitted ext4_end_io_dio() was not
3058 * called so we have to put iocb's reference.
3059 */
3065 }
3066 }
3068 EXT4_STATE_DIO_UNWRITTEN)) {
3070 /*
3071 * for non AIO case, since the IO is already
3072 * completed, we could do the conversion right here
3073 */
3079 }
3081 retake_lock:
3084 /* take i_mutex locking again if we do a ovewrite dio */
3088 }
3091 }
3095 {
3099 ssize_t ret;
3101 /*
3102 * If we are doing data journalling we don't support O_DIRECT
3103 */
3107 /* Let buffer I/O handle the inline data case. */
3114 else
3118 }
3120 /*
3121 * Pages can be marked dirty completely asynchronously from ext4's journalling
3122 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
3123 * much here because ->set_page_dirty is called under VFS locks. The page is
3124 * not necessarily locked.
3125 *
3126 * We cannot just dirty the page and leave attached buffers clean, because the
3127 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
3128 * or jbddirty because all the journalling code will explode.
3129 *
3130 * So what we do is to mark the page "pending dirty" and next time writepage
3131 * is called, propagate that into the buffers appropriately.
3132 */
3134 {
3137 }
3153 };
3169 };
3185 };
3188 {
3201 }
3204 else
3206 }
3210 {
3214 ext4_lblk_t iblock;
3232 /* Find the buffer that contains "offset" */
3237 iblock++;
3239 }
3243 }
3247 /* unmapped? It's a hole - nothing to do */
3251 }
3252 }
3254 /* Ok, it's mapped. Make sure it's up-to-date */
3262 /* Uhhuh. Read error. Complain and punt. */
3265 }
3271 }
3282 }
3284 unlock:
3288 }
3290 /*
3291 * ext4_block_zero_page_range() zeros out a mapping of length 'length'
3292 * starting from file offset 'from'. The range to be zero'd must
3293 * be contained with in one block. If the specified range exceeds
3294 * the end of the block it will be shortened to end of the block
3295 * that cooresponds to 'from'
3296 */
3299 {
3305 /*
3306 * correct length if it does not fall between
3307 * 'from' and the end of the block
3308 */
3315 }
3317 /*
3318 * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
3319 * up to the end of the block which corresponds to `from'.
3320 * This required during truncate. We need to physically zero the tail end
3321 * of that block so it doesn't yield old data if the file is later grown.
3322 */
3325 {
3335 }
3339 {
3353 /* Handle partial zero within the single block */
3359 }
3360 /* Handle partial zero out on the start of the range */
3366 }
3367 /* Handle partial zero out on the end of the range */
3373 }
3376 {
3384 }
3386 /*
3387 * ext4_punch_hole: punches a hole in a file by releaseing the blocks
3388 * associated with the given offset and length
3389 *
3390 * @inode: File inode
3391 * @offset: The offset where the hole will begin
3392 * @len: The length of the hole
3393 *
3394 * Returns: 0 on success or negative on failure
3395 */
3398 {
3412 /*
3413 * Write out all dirty pages to avoid race conditions
3414 * Then release them.
3415 */
3421 }
3425 /* No need to punch hole beyond i_size */
3429 /*
3430 * If the hole extends beyond i_size, set the hole
3431 * to end after the page that contains i_size
3432 */
3436 offset;
3437 }
3441 /*
3442 * Attach jinode to inode for jbd2 if we do any zeroing of
3443 * partial block
3444 */
3449 }
3454 /* Now release the pages and zero block aligned part of pages*/
3457 last_block_offset);
3459 /* Wait all existing dio workers, newcomers will block on i_mutex */
3465 else
3472 }
3475 length);
3483 /* If there are no blocks to remove, return now */
3495 }
3500 else
3502 stop_block);
3508 /* Now release the pages again to reduce race window */
3511 last_block_offset);
3515 out_stop:
3517 out_dio:
3519 out_mutex:
3522 }
3525 {
3538 }
3542 }
3547 }
3549 /*
3550 * ext4_truncate()
3551 *
3552 * We block out ext4_get_block() block instantiations across the entire
3553 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3554 * simultaneously on behalf of the same inode.
3555 *
3556 * As we work through the truncate and commit bits of it to the journal there
3557 * is one core, guiding principle: the file's tree must always be consistent on
3558 * disk. We must be able to restart the truncate after a crash.
3559 *
3560 * The file's tree may be transiently inconsistent in memory (although it
3561 * probably isn't), but whenever we close off and commit a journal transaction,
3562 * the contents of (the filesystem + the journal) must be consistent and
3563 * restartable. It's pretty simple, really: bottom up, right to left (although
3564 * left-to-right works OK too).
3565 *
3566 * Note that at recovery time, journal replay occurs *before* the restart of
3567 * truncate against the orphan inode list.
3568 *
3569 * The committed inode has the new, desired i_size (which is the same as
3570 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see
3571 * that this inode's truncate did not complete and it will again call
3572 * ext4_truncate() to have another go. So there will be instantiated blocks
3573 * to the right of the truncation point in a crashed ext4 filesystem. But
3574 * that's fine - as long as they are linked from the inode, the post-crash
3575 * ext4_truncate() run will find them and release them.
3576 */
3578 {
3584 /*
3585 * There is a possibility that we're either freeing the inode
3586 * or it's a completely new inode. In those cases we might not
3587 * have i_mutex locked because it's not necessary.
3588 */
3607 }
3609 /* If we zero-out tail of the page, we have to create jinode for jbd2 */
3613 }
3617 else
3624 }
3629 /*
3630 * We add the inode to the orphan list, so that if this
3631 * truncate spans multiple transactions, and we crash, we will
3632 * resume the truncate when the filesystem recovers. It also
3633 * marks the inode dirty, to catch the new size.
3634 *
3635 * Implication: the file must always be in a sane, consistent
3636 * truncatable state while each transaction commits.
3637 */
3647 else
3655 out_stop:
3656 /*
3657 * If this was a simple ftruncate() and the file will remain alive,
3658 * then we need to clear up the orphan record which we created above.
3659 * However, if this was a real unlink then we were called by
3660 * ext4_evict_inode(), and we allow that function to clean up the
3661 * orphan info for us.
3662 */
3671 }
3673 /*
3674 * ext4_get_inode_loc returns with an extra refcount against the inode's
3675 * underlying buffer_head on success. If 'in_mem' is true, we have all
3676 * data in memory that is needed to recreate the on-disk version of this
3677 * inode.
3678 */
3681 {
3685 ext4_fsblk_t block;
3697 /*
3698 * Figure out the offset within the block group inode table
3699 */
3712 /*
3713 * If the buffer has the write error flag, we have failed
3714 * to write out another inode in the same block. In this
3715 * case, we don't have to read the block because we may
3716 * read the old inode data successfully.
3717 */
3722 /* someone brought it uptodate while we waited */
3725 }
3727 /*
3728 * If we have all information of the inode in memory and this
3729 * is the only valid inode in the block, we need not read the
3730 * block.
3731 */
3738 /* Is the inode bitmap in cache? */
3743 /*
3744 * If the inode bitmap isn't in cache then the
3745 * optimisation may end up performing two reads instead
3746 * of one, so skip it.
3747 */
3751 }
3757 }
3760 /* all other inodes are free, so skip I/O */
3765 }
3766 }
3768 make_io:
3769 /*
3770 * If we need to do any I/O, try to pre-readahead extra
3771 * blocks from the inode table.
3772 */
3779 /* s_inode_readahead_blks is always a power of 2 */
3792 }
3794 /*
3795 * There are other valid inodes in the buffer, this inode
3796 * has in-inode xattrs, or we don't have this inode in memory.
3797 * Read the block from disk.
3798 */
3809 }
3810 }
3811 has_buffer:
3814 }
3817 {
3818 /* We have all inode data except xattrs in memory here. */
3821 }
3824 {
3842 }
3844 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3846 {
3855 EXT4_DIRSYNC_FL);
3867 }
3871 {
3872 blkcnt_t i_blocks ;
3877 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
3878 /* we are using combined 48 bit field */
3882 /* i_blocks represent file system block size */
3886 }
3889 }
3890 }
3895 {
3903 }
3906 {
3914 uid_t i_uid;
3915 gid_t i_gid;
3940 }
3944 /* Precompute checksum seed for inode metadata */
3947 __u32 csum;
3954 }
3960 }
3968 }
3977 /* We now have enough fields to check if the inode was active or not.
3978 * This is needed because nfsd might try to access dead inodes
3979 * the test is that same one that e2fsck uses
3980 * NeilBrown 1999oct15
3981 */
3986 /* this inode is deleted */
3989 }
3990 /* The only unlinked inodes we let through here have
3991 * valid i_mode and are being read by the orphan
3992 * recovery code: that's fine, we're about to complete
3993 * the process of deleting those.
3994 * OR it is the EXT4_BOOT_LOADER_INO which is
3995 * not initialized on a new filesystem. */
3996 }
4005 #ifdef CONFIG_QUOTA
4007 #endif
4011 /*
4012 * NOTE! The in-memory inode i_data array is in little-endian order
4013 * even on big-endian machines: we do NOT byteswap the block numbers!
4014 */
4019 /*
4020 * Set transaction id's of transactions that have to be committed
4021 * to finish f[data]sync. We set them to currently running transaction
4022 * as we cannot be sure that the inode or some of its metadata isn't
4023 * part of the transaction - the inode could have been reclaimed and
4024 * now it is reread from disk.
4025 */
4028 tid_t tid;
4033 else
4037 else
4042 }
4046 /* The extra space is currently unused. Use it. */
4048 EXT4_GOOD_OLD_INODE_SIZE;
4051 }
4052 }
4065 }
4066 }
4080 /* Validate extent which is part of inode */
4085 /* Validate block references which are part of inode */
4087 }
4088 }
4096 else
4110 }
4117 else
4126 }
4132 bad_inode:
4136 }
4139 {
4143 }
4148 {
4154 /*
4155 * i_blocks can be represented in a 32 bit variable
4156 * as multiple of 512 bytes
4157 */
4162 }
4167 /*
4168 * i_blocks can be represented in a 48 bit variable
4169 * as multiple of 512 bytes
4170 */
4176 /* i_block is stored in file system block size */
4180 }
4182 }
4187 };
4191 {
4216 }
4219 }
4221 /*
4222 * Opportunistically update the other time fields for other inodes in
4223 * the same inode table block.
4224 */
4227 {
4240 }
4241 }
4243 /*
4244 * Post the struct inode info into an on-disk inode location in the
4245 * buffer-cache. This gobbles the caller's reference to the
4246 * buffer_head in the inode location struct.
4247 *
4248 * The caller must have write access to iloc->bh.
4249 */
4253 {
4260 uid_t i_uid;
4261 gid_t i_gid;
4265 /* For fields not tracked in the in-memory inode,
4266 * initialise them to zero for new inodes. */
4277 /*
4278 * Fix up interoperability with old kernels. Otherwise, old inodes get
4279 * re-used with the upper 16 bits of the uid/gid intact
4280 */
4289 }
4295 }
4307 }
4317 }
4320 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4324 }
4336 }
4340 }
4350 }
4351 }
4370 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4373 }
4375 out_brelse:
4379 }
4381 /*
4382 * ext4_write_inode()
4383 *
4384 * We are called from a few places:
4385 *
4386 * - Within generic_file_aio_write() -> generic_write_sync() for O_SYNC files.
4387 * Here, there will be no transaction running. We wait for any running
4388 * transaction to commit.
4389 *
4390 * - Within flush work (sys_sync(), kupdate and such).
4391 * We wait on commit, if told to.
4392 *
4393 * - Within iput_final() -> write_inode_now()
4394 * We wait on commit, if told to.
4395 *
4396 * In all cases it is actually safe for us to return without doing anything,
4397 * because the inode has been copied into a raw inode buffer in
4398 * ext4_mark_inode_dirty(). This is a correctness thing for WB_SYNC_ALL
4399 * writeback.
4400 *
4401 * Note that we are absolutely dependent upon all inode dirtiers doing the
4402 * right thing: they *must* call mark_inode_dirty() after dirtying info in
4403 * which we are interested.
4404 *
4405 * It would be a bug for them to not do this. The code:
4406 *
4407 * mark_inode_dirty(inode)
4408 * stuff();
4409 * inode->i_size = expr;
4410 *
4411 * is in error because write_inode() could occur while `stuff()' is running,
4412 * and the new i_size will be lost. Plus the inode will no longer be on the
4413 * superblock's dirty inode list.
4414 */
4416 {
4427 }
4429 /*
4430 * No need to force transaction in WB_SYNC_NONE mode. Also
4431 * ext4_sync_fs() will force the commit after everything is
4432 * written.
4433 */
4444 /*
4445 * sync(2) will flush the whole buffer cache. No need to do
4446 * it here separately for each inode.
4447 */
4454 }
4456 }
4458 }
4460 /*
4461 * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
4462 * buffers that are attached to a page stradding i_size and are undergoing
4463 * commit. In that case we have to wait for commit to finish and try again.
4464 */
4466 {
4474 /*
4475 * All buffers in the last page remain valid? Then there's nothing to
4476 * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
4477 * blocksize case
4478 */
4499 }
4500 }
4502 /*
4503 * ext4_setattr()
4504 *
4505 * Called from notify_change.
4506 *
4507 * We want to trap VFS attempts to truncate the file as soon as
4508 * possible. In particular, we want to make sure that when the VFS
4509 * shrinks i_size, we put the inode on the orphan list and modify
4510 * i_disksize immediately, so that during the subsequent flushing of
4511 * dirty pages and freeing of disk blocks, we can guarantee that any
4512 * commit will leave the blocks being flushed in an unused state on
4513 * disk. (On recovery, the inode will get truncated and the blocks will
4514 * be freed, so we have a strong guarantee that no future commit will
4515 * leave these blocks visible to the user.)
4516 *
4517 * Another thing we have to assure is that if we are in ordered mode
4518 * and inode is still attached to the committing transaction, we must
4519 * we start writeout of all the dirty pages which are being truncated.
4520 * This way we are sure that all the data written in the previous
4521 * transaction are already on disk (truncate waits for pages under
4522 * writeback).
4523 *
4524 * Called with inode->i_mutex down.
4525 */
4527 {
4543 /* (user+group)*(old+new) structure, inode write (sb,
4544 * inode block, ? - but truncate inode update has it) */
4551 }
4556 }
4557 /* Update corresponding info in inode so that everything is in
4558 * one transaction */
4565 }
4575 }
4587 }
4592 }
4596 }
4602 /*
4603 * We have to update i_size under i_data_sem together
4604 * with i_disksize to avoid races with writeback code
4605 * running ext4_wb_update_i_disksize().
4606 */
4614 }
4620 }
4622 /*
4623 * Blocks are going to be removed from the inode. Wait
4624 * for dio in flight. Temporarily disable
4625 * dioread_nolock to prevent livelock.
4626 */
4634 }
4635 /*
4636 * Truncate pagecache after we've waited for commit
4637 * in data=journal mode to make pages freeable.
4638 */
4640 }
4641 /*
4642 * We want to call ext4_truncate() even if attr->ia_size ==
4643 * inode->i_size for cases like truncation of fallocated space
4644 */
4651 }
4653 /*
4654 * If the call to ext4_truncate failed to get a transaction handle at
4655 * all, we need to clean up the in-core orphan list manually.
4656 */
4663 err_out:
4668 }
4672 {
4679 /*
4680 * If there is inline data in the inode, the inode will normally not
4681 * have data blocks allocated (it may have an external xattr block).
4682 * Report at least one sector for such files, so tools like tar, rsync,
4683 * others doen't incorrectly think the file is completely sparse.
4684 */
4688 /*
4689 * We can't update i_blocks if the block allocation is delayed
4690 * otherwise in the case of system crash before the real block
4691 * allocation is done, we will have i_blocks inconsistent with
4692 * on-disk file blocks.
4693 * We always keep i_blocks updated together with real
4694 * allocation. But to not confuse with user, stat
4695 * will return the blocks that include the delayed allocation
4696 * blocks for this file.
4697 */
4702 }
4706 {
4710 }
4712 /*
4713 * Account for index blocks, block groups bitmaps and block group
4714 * descriptor blocks if modify datablocks and index blocks
4715 * worse case, the indexs blocks spread over different block groups
4716 *
4717 * If datablocks are discontiguous, they are possible to spread over
4718 * different block groups too. If they are contiguous, with flexbg,
4719 * they could still across block group boundary.
4720 *
4721 * Also account for superblock, inode, quota and xattr blocks
4722 */
4725 {
4731 /*
4732 * How many index blocks need to touch to map @lblocks logical blocks
4733 * to @pextents physical extents?
4734 */
4739 /*
4740 * Now let's see how many group bitmaps and group descriptors need
4741 * to account
4742 */
4750 /* bitmaps and block group descriptor blocks */
4753 /* Blocks for super block, inode, quota and xattr blocks */
4757 }
4759 /*
4760 * Calculate the total number of credits to reserve to fit
4761 * the modification of a single pages into a single transaction,
4762 * which may include multiple chunks of block allocations.
4763 *
4764 * This could be called via ext4_write_begin()
4765 *
4766 * We need to consider the worse case, when
4767 * one new block per extent.
4768 */
4770 {
4776 /* Account for data blocks for journalled mode */
4780 }
4782 /*
4783 * Calculate the journal credits for a chunk of data modification.
4784 *
4785 * This is called from DIO, fallocate or whoever calling
4786 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4787 *
4788 * journal buffers for data blocks are not included here, as DIO
4789 * and fallocate do no need to journal data buffers.
4790 */
4792 {
4794 }
4796 /*
4797 * The caller must have previously called ext4_reserve_inode_write().
4798 * Give this, we know that the caller already has write access to iloc->bh.
4799 */
4802 {
4808 /* the do_update_inode consumes one bh->b_count */
4811 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4815 }
4817 /*
4818 * On success, We end up with an outstanding reference count against
4819 * iloc->bh. This _must_ be cleaned up later.
4820 */
4822 int
4825 {
4835 }
4836 }
4839 }
4841 /*
4842 * Expand an inode by new_extra_isize bytes.
4843 * Returns 0 on success or negative error number on failure.
4844 */
4849 {
4860 /* No extended attributes present */
4864 new_extra_isize);
4867 }
4869 /* try to expand with EAs present */
4872 }
4874 /*
4875 * What we do here is to mark the in-core inode as clean with respect to inode
4876 * dirtiness (it may still be data-dirty).
4877 * This means that the in-core inode may be reaped by prune_icache
4878 * without having to perform any I/O. This is a very good thing,
4879 * because *any* task may call prune_icache - even ones which
4880 * have a transaction open against a different journal.
4881 *
4882 * Is this cheating? Not really. Sure, we haven't written the
4883 * inode out, but prune_icache isn't a user-visible syncing function.
4884 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4885 * we start and wait on commits.
4886 */
4888 {
4900 /*
4901 * We need extra buffer credits since we may write into EA block
4902 * with this same handle. If journal_extend fails, then it will
4903 * only result in a minor loss of functionality for that inode.
4904 * If this is felt to be critical, then e2fsck should be run to
4905 * force a large enough s_min_extra_isize.
4906 */
4914 EXT4_STATE_NO_EXPAND);
4918 "Unable to expand inode %lu. Delete"
4921 mnt_count =
4923 }
4924 }
4925 }
4926 }
4930 }
4932 /*
4933 * ext4_dirty_inode() is called from __mark_inode_dirty()
4934 *
4935 * We're really interested in the case where a file is being extended.
4936 * i_size has been changed by generic_commit_write() and we thus need
4937 * to include the updated inode in the current transaction.
4938 *
4939 * Also, dquot_alloc_block() will always dirty the inode when blocks
4940 * are allocated to the file.
4941 *
4942 * If the inode is marked synchronous, we don't honour that here - doing
4943 * so would cause a commit on atime updates, which we don't bother doing.
4944 * We handle synchronous inodes at the highest possible level.
4945 *
4946 * If only the I_DIRTY_TIME flag is set, we can skip everything. If
4947 * I_DIRTY_TIME and I_DIRTY_SYNC is set, the only inode fields we need
4948 * to copy into the on-disk inode structure are the timestamp files.
4949 */
4951 {
4963 out:
4965 }
4967 #if 0
4968 /*
4969 * Bind an inode's backing buffer_head into this transaction, to prevent
4970 * it from being flushed to disk early. Unlike
4971 * ext4_reserve_inode_write, this leaves behind no bh reference and
4972 * returns no iloc structure, so the caller needs to repeat the iloc
4973 * lookup to mark the inode dirty later.
4974 */
4976 {
4987 NULL,
4990 }
4991 }
4994 }
4995 #endif
4998 {
5003 /*
5004 * We have to be very careful here: changing a data block's
5005 * journaling status dynamically is dangerous. If we write a
5006 * data block to the journal, change the status and then delete
5007 * that block, we risk forgetting to revoke the old log record
5008 * from the journal and so a subsequent replay can corrupt data.
5009 * So, first we make sure that the journal is empty and that
5010 * nobody is changing anything.
5011 */
5018 /* We have to allocate physical blocks for delalloc blocks
5019 * before flushing journal. otherwise delalloc blocks can not
5020 * be allocated any more. even more truncate on delalloc blocks
5021 * could trigger BUG by flushing delalloc blocks in journal.
5022 * There is no delalloc block in non-journal data mode.
5023 */
5028 }
5030 /* Wait for all existing dio workers */
5036 /*
5037 * OK, there are no updates running now, and all cached data is
5038 * synced to disk. We are now in a completely consistent state
5039 * which doesn't have anything in the journal, and we know that
5040 * no filesystem updates are running, so it is safe to modify
5041 * the inode's in-core data-journaling state flag now.
5042 */
5052 }
5054 }
5060 /* Finally we can mark the inode as dirty. */
5072 }
5075 {
5077 }
5080 {
5082 loff_t size;
5094 /* Delalloc case is easy... */
5100 ext4_da_get_block_prep);
5104 }
5108 /* Page got truncated from under us? */
5113 }
5117 else
5119 /*
5120 * Return if we have all the buffers mapped. This avoids the need to do
5121 * journal_start/journal_stop which can block and take a long time
5122 */
5126 ext4_bh_unmapped)) {
5127 /* Wait so that we don't change page under IO */
5131 }
5132 }
5134 /* OK, we need to fill the hole... */
5137 else
5139 retry_alloc:
5145 }
5154 }
5156 }
5160 out_ret:
5162 out:
5165 }