| blob | cbfe13bf5b2aa3f39b4845fe4fce4f45a02b5f43 |
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>
46 #include <trace/events/ext4.h>
48 #define MPAGE_DA_EXTENT_TAIL 0x01
52 {
54 __u16 csum_lo;
56 __u32 csum;
64 }
75 }
79 {
85 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
93 else
97 }
101 {
102 __u32 csum;
107 EXT4_FEATURE_RO_COMPAT_METADATA_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 }
145 /*
146 * Test whether an inode is a fast symlink.
147 */
149 {
154 }
156 /*
157 * Restart the transaction associated with *handle. This does a commit,
158 * so before we call here everything must be consistently dirtied against
159 * this transaction.
160 */
163 {
166 /*
167 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
168 * moment, get_block can be called only for blocks inside i_size since
169 * page cache has been already dropped and writes are blocked by
170 * i_mutex. So we can safely drop the i_data_sem here.
171 */
180 }
182 /*
183 * Called at the last iput() if i_nlink is zero.
184 */
186 {
195 /*
196 * When journalling data dirty buffers are tracked only in the
197 * journal. So although mm thinks everything is clean and
198 * ready for reaping the inode might still have some pages to
199 * write in the running transaction or waiting to be
200 * checkpointed. Thus calling jbd2_journal_invalidatepage()
201 * (via truncate_inode_pages()) to discard these buffers can
202 * cause data loss. Also even if we did not discard these
203 * buffers, we would have no way to find them after the inode
204 * is reaped and thus user could see stale data if he tries to
205 * read them before the transaction is checkpointed. So be
206 * careful and force everything to disk here... We use
207 * ei->i_datasync_tid to store the newest transaction
208 * containing inode's data.
209 *
210 * Note that directories do not have this problem because they
211 * don't use page cache.
212 */
221 }
224 }
236 /*
237 * Protect us against freezing - iput() caller didn't have to have any
238 * protection against it
239 */
244 /*
245 * If we're going to skip the normal cleanup, we still need to
246 * make sure that the in-core orphan linked list is properly
247 * cleaned up.
248 */
252 }
262 }
266 /*
267 * ext4_ext_truncate() doesn't reserve any slop when it
268 * restarts journal transactions; therefore there may not be
269 * enough credits left in the handle to remove the inode from
270 * the orphan list and set the dtime field.
271 */
279 stop_handle:
284 }
285 }
287 /*
288 * Kill off the orphan record which ext4_truncate created.
289 * AKPM: I think this can be inside the above `if'.
290 * Note that ext4_orphan_del() has to be able to cope with the
291 * deletion of a non-existent orphan - this is because we don't
292 * know if ext4_truncate() actually created an orphan record.
293 * (Well, we could do this if we need to, but heck - it works)
294 */
298 /*
299 * One subtle ordering requirement: if anything has gone wrong
300 * (transaction abort, IO errors, whatever), then we can still
301 * do these next steps (the fs will already have been marked as
302 * having errors), but we can't free the inode if the mark_dirty
303 * fails.
304 */
306 /* If that failed, just do the required in-core inode clear. */
308 else
313 no_delete:
315 }
317 #ifdef CONFIG_QUOTA
319 {
321 }
322 #endif
324 /*
325 * Calculate the number of metadata blocks need to reserve
326 * to allocate a block located at @lblock
327 */
329 {
334 }
336 /*
337 * Called with i_data_sem down, which is important since we can call
338 * ext4_discard_preallocations() from here.
339 */
342 {
355 }
364 }
366 /* Update per-inode reservations */
374 /*
375 * We can release all of the reserved metadata blocks
376 * only when we have written all of the delayed
377 * allocation blocks.
378 */
383 }
386 /* Update quota subsystem for data blocks */
390 /*
391 * We did fallocate with an offset that is already delayed
392 * allocated. So on delayed allocated writeback we should
393 * not re-claim the quota for fallocated blocks.
394 */
396 }
398 /*
399 * If we have done all the pending block allocations and if
400 * there aren't any writers on the inode, we can discard the
401 * inode's preallocations.
402 */
406 }
411 {
415 "lblock %lu mapped to illegal pblock "
419 }
421 }
423 #define check_block_validity(inode, map) \
424 __check_block_validity((inode), __func__, __LINE__, (map))
426 /*
427 * Return the number of contiguous dirty pages in a given inode
428 * starting at page frame idx.
429 */
432 {
434 pgoff_t index;
445 PAGECACHE_TAG_DIRTY,
461 }
470 }
474 idx++;
475 num++;
479 }
480 }
482 }
484 }
486 /*
487 * The ext4_map_blocks() function tries to look up the requested blocks,
488 * and returns if the blocks are already mapped.
489 *
490 * Otherwise it takes the write lock of the i_data_sem and allocate blocks
491 * and store the allocated blocks in the result buffer head and mark it
492 * mapped.
493 *
494 * If file type is extents based, it will call ext4_ext_map_blocks(),
495 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
496 * based files
497 *
498 * On success, it returns the number of blocks being mapped or allocate.
499 * if create==0 and the blocks are pre-allocated and uninitialized block,
500 * the result buffer head is unmapped. If the create ==1, it will make sure
501 * the buffer head is mapped.
502 *
503 * It returns 0 if plain look up failed (blocks have not been allocated), in
504 * that case, buffer head is unmapped
505 *
506 * It returns the error in case of allocation failure.
507 */
510 {
517 /*
518 * Try to see if we can get the block without requesting a new
519 * file system block.
520 */
525 EXT4_GET_BLOCKS_KEEP_SIZE);
528 EXT4_GET_BLOCKS_KEEP_SIZE);
529 }
536 /* delayed alloc may be allocated by fallocate and
537 * coverted to initialized by directIO.
538 * we need to handle delayed extent here.
539 */
542 }
546 }
548 /* If it is only a block(s) look up */
552 /*
553 * Returns if the blocks have already allocated
554 *
555 * Note that if blocks have been preallocated
556 * ext4_ext_get_block() returns the create = 0
557 * with buffer head unmapped.
558 */
562 /*
563 * When we call get_blocks without the create flag, the
564 * BH_Unwritten flag could have gotten set if the blocks
565 * requested were part of a uninitialized extent. We need to
566 * clear this flag now that we are committed to convert all or
567 * part of the uninitialized extent to be an initialized
568 * extent. This is because we need to avoid the combination
569 * of BH_Unwritten and BH_Mapped flags being simultaneously
570 * set on the buffer_head.
571 */
574 /*
575 * New blocks allocate and/or writing to uninitialized extent
576 * will possibly result in updating i_data, so we take
577 * the write lock of i_data_sem, and call get_blocks()
578 * with create == 1 flag.
579 */
582 /*
583 * if the caller is from delayed allocation writeout path
584 * we have already reserved fs blocks for allocation
585 * let the underlying get_block() function know to
586 * avoid double accounting
587 */
590 /*
591 * We need to check for EXT4 here because migrate
592 * could have changed the inode type in between
593 */
600 /*
601 * We allocated new blocks which will result in
602 * i_data's format changing. Force the migrate
603 * to fail by clearing migrate flags
604 */
606 }
608 /*
609 * Update reserved blocks/metadata blocks after successful
610 * block allocation which had been deferred till now. We don't
611 * support fallocate for non extent files. So we can update
612 * reserve space here.
613 */
617 }
623 delayed_mapped:
624 /* delayed allocation blocks has been allocated */
629 }
630 }
637 }
639 }
641 /* Maximum number of blocks we map for direct IO at once. */
642 #define DIO_MAX_BLOCKS 4096
646 {
659 /* Direct IO write... */
667 }
669 }
677 }
681 }
685 {
688 }
690 /*
691 * `handle' can be NULL if create is zero
692 */
695 {
707 /* ensure we send some value back into *errp */
719 }
724 /*
725 * Now that we do not always journal data, we should
726 * keep in mind whether this should always journal the
727 * new buffer as metadata. For now, regular file
728 * writes use ext4_get_block instead, so it's not a
729 * problem.
730 */
737 }
745 }
750 }
752 }
756 {
771 }
780 {
796 }
800 }
802 }
804 /*
805 * To preserve ordering, it is essential that the hole instantiation and
806 * the data write be encapsulated in a single transaction. We cannot
807 * close off a transaction and start a new one between the ext4_get_block()
808 * and the commit_write(). So doing the jbd2_journal_start at the start of
809 * prepare_write() is the right place.
810 *
811 * Also, this function can nest inside ext4_writepage() ->
812 * block_write_full_page(). In that case, we *know* that ext4_writepage()
813 * has generated enough buffer credits to do the whole page. So we won't
814 * block on the journal in that case, which is good, because the caller may
815 * be PF_MEMALLOC.
816 *
817 * By accident, ext4 can be reentered when a transaction is open via
818 * quota file writes. If we were to commit the transaction while thus
819 * reentered, there can be a deadlock - we would be holding a quota
820 * lock, and the commit would never complete if another thread had a
821 * transaction open and was blocking on the quota lock - a ranking
822 * violation.
823 *
824 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
825 * will _not_ run commit under these circumstances because handle->h_ref
826 * is elevated. We'll still have enough credits for the tiny quotafile
827 * write.
828 */
831 {
837 /*
838 * __block_write_begin() could have dirtied some buffers. Clean
839 * the dirty bit as jbd2_journal_get_write_access() could complain
840 * otherwise about fs integrity issues. Setting of the dirty bit
841 * by __block_write_begin() isn't a real problem here as we clear
842 * the bit before releasing a page lock and thus writeback cannot
843 * ever write the buffer.
844 */
851 }
858 {
864 pgoff_t index;
868 /*
869 * Reserve one block more for addition to orphan list in case
870 * we allocate blocks but write fails for some reason
871 */
885 }
886 }
888 retry:
893 }
895 /* We cannot recurse into the filesystem as the transaction is already
896 * started */
904 }
910 else
916 do_journal_get_write_access);
917 }
922 /*
923 * __block_write_begin may have instantiated a few blocks
924 * outside i_size. Trim these off again. Don't need
925 * i_size_read because we hold i_mutex.
926 *
927 * Add inode to orphan list in case we crash before
928 * truncate finishes
929 */
936 /*
937 * If truncate failed early the inode might
938 * still be on the orphan list; we need to
939 * make sure the inode is removed from the
940 * orphan list in that case.
941 */
944 }
945 }
949 out:
951 }
953 /* For write_end() in data=journal mode */
955 {
960 }
966 {
974 else
978 /*
979 * No need to use i_size_read() here, the i_size
980 * cannot change under us because we hold i_mutex.
981 *
982 * But it's important to update i_size while still holding page lock:
983 * page writeout could otherwise come in and zero beyond i_size.
984 */
988 }
991 /* We need to mark inode dirty even if
992 * new_i_size is less that inode->i_size
993 * bu greater than i_disksize.(hint delalloc)
994 */
997 }
1001 /*
1002 * Don't mark the inode dirty under page lock. First, it unnecessarily
1003 * makes the holding time of page lock longer. Second, it forces lock
1004 * ordering of page lock and transaction start for journaling
1005 * filesystems.
1006 */
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 {
1037 /* if we have allocated more blocks and copied
1038 * less. We will have blocks allocated outside
1039 * inode->i_size. So truncate them
1040 */
1047 }
1055 /*
1056 * If truncate failed early the inode might still be
1057 * on the orphan list; we need to make sure the inode
1058 * is removed from the orphan list in that case.
1059 */
1062 }
1066 }
1072 {
1082 /* if we have allocated more blocks and copied
1083 * less. We will have blocks allocated outside
1084 * inode->i_size. So truncate them
1085 */
1097 /*
1098 * If truncate failed early the inode might still be
1099 * on the orphan list; we need to make sure the inode
1100 * is removed from the orphan list in that case.
1101 */
1104 }
1107 }
1113 {
1119 loff_t new_i_size;
1135 }
1141 }
1152 }
1157 /* if we have allocated more blocks and copied
1158 * less. We will have blocks allocated outside
1159 * inode->i_size. So truncate them
1160 */
1168 /*
1169 * If truncate failed early the inode might still be
1170 * on the orphan list; we need to make sure the inode
1171 * is removed from the orphan list in that case.
1172 */
1175 }
1178 }
1180 /*
1181 * Reserve a single cluster located at lblock
1182 */
1184 {
1190 ext4_lblk_t save_last_lblock;
1193 /*
1194 * We will charge metadata quota at writeout time; this saves
1195 * us from metadata over-estimation, though we may go over by
1196 * a small amount in the end. Here we just reserve for data.
1197 */
1202 /*
1203 * recalculate the amount of metadata blocks to reserve
1204 * in order to allocate nrblocks
1205 * worse case is one extent per block
1206 */
1207 repeat:
1209 /*
1210 * ext4_calc_metadata_amount() has side effects, which we have
1211 * to be prepared undo if we fail to claim space.
1212 */
1219 /*
1220 * We do still charge estimated metadata to the sb though;
1221 * we cannot afford to run out of free blocks.
1222 */
1230 }
1233 }
1239 }
1242 {
1253 /*
1254 * if there aren't enough reserved blocks, then the
1255 * counter is messed up somewhere. Since this
1256 * function is called from invalidate page, it's
1257 * harmless to return without any action.
1258 */
1260 "ino %lu, to_free %d with only %d reserved "
1265 }
1269 /*
1270 * We can release all of the reserved metadata blocks
1271 * only when we have written all of the delayed
1272 * allocation blocks.
1273 * Note that in case of bigalloc, i_reserved_meta_blocks,
1274 * i_reserved_data_blocks, etc. refer to number of clusters.
1275 */
1280 }
1282 /* update fs dirty data blocks counter */
1288 }
1292 {
1299 ext4_fsblk_t lblk;
1307 to_release++;
1309 }
1316 }
1318 /* If we have released all the blocks belonging to a cluster, then we
1319 * need to release the reserved space for that cluster. */
1328 num_clusters--;
1329 }
1330 }
1332 /*
1333 * Delayed allocation stuff
1334 */
1336 /*
1337 * mpage_da_submit_io - walks through extent of pages and try to write
1338 * them with writepage() call back
1339 *
1340 * @mpd->inode: inode
1341 * @mpd->first_page: first page of the extent
1342 * @mpd->next_page: page after the last page of the extent
1343 *
1344 * By the time mpage_da_submit_io() is called we expect all blocks
1345 * to be allocated. this may be wrong if allocation failed.
1346 *
1347 * As pages are already locked by write_cache_pages(), we can't use it
1348 */
1351 {
1366 /*
1367 * We need to start from the first_page to the next_page - 1
1368 * to make sure we also write the mapped dirty buffer_heads.
1369 * If we look at mpd->b_blocknr we would only be looking
1370 * at the currently mapped buffer_heads.
1371 */
1390 else
1397 }
1398 index++;
1403 /*
1404 * If the page does not have buffers (for
1405 * whatever reason), try to create them using
1406 * __block_write_begin. If this fails,
1407 * skip the page and move on.
1408 */
1411 noalloc_get_block_write)) {
1412 skip_page:
1415 }
1417 }
1430 }
1437 }
1439 /*
1440 * skip page if block allocation undone and
1441 * block is dirty
1442 */
1447 cur_logical++;
1448 pblock++;
1455 /* mark the buffer_heads as dirty & uptodate */
1459 /*
1460 * Delalloc doesn't support data journalling,
1461 * but eventually maybe we'll lift this
1462 * restriction.
1463 */
1472 noalloc_get_block_write,
1480 /*
1481 * In error case, we have to continue because
1482 * remaining pages are still locked
1483 */
1486 }
1488 }
1491 }
1494 {
1523 }
1526 }
1528 }
1531 {
1551 }
1553 /*
1554 * mpage_da_map_and_submit - go through given space, map them
1555 * if necessary, and then submit them for I/O
1556 *
1557 * @mpd - bh describing space
1558 *
1559 * The function skips space we know is already mapped to disk blocks.
1560 *
1561 */
1563 {
1571 /*
1572 * If the blocks are mapped already, or we couldn't accumulate
1573 * any blocks, then proceed immediately to the submission stage.
1574 */
1584 /*
1585 * Call ext4_map_blocks() to allocate any delayed allocation
1586 * blocks, or to convert an uninitialized extent to be
1587 * initialized (in the case where we have written into
1588 * one or more preallocated blocks).
1589 *
1590 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
1591 * indicate that we are on the delayed allocation path. This
1592 * affects functions in many different parts of the allocation
1593 * call path. This flag exists primarily because we don't
1594 * want to change *many* call functions, so ext4_map_blocks()
1595 * will set the EXT4_STATE_DELALLOC_RESERVED flag once the
1596 * inode's allocation semaphore is taken.
1597 *
1598 * If the blocks in questions were delalloc blocks, set
1599 * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
1600 * variables are updated after the blocks have been allocated.
1601 */
1615 /*
1616 * If get block returns EAGAIN or ENOSPC and there
1617 * appears to be free blocks we will just let
1618 * mpage_da_submit_io() unlock all of the pages.
1619 */
1626 }
1628 /*
1629 * get block failure will cause us to loop in
1630 * writepages, because a_ops->writepage won't be able
1631 * to make progress. The page will be redirtied by
1632 * writepage and writepages will again try to write
1633 * the same.
1634 */
1637 "delayed block allocation failed for inode %lu "
1638 "at logical offset %llu with max blocks %zd "
1646 }
1647 /* invalidate all the pages */
1650 /* Mark this page range as having been completed */
1653 }
1663 }
1665 /*
1666 * Update on-disk size along with block allocation.
1667 */
1678 }
1680 submit_io:
1683 }
1685 #define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
1686 (1 << BH_Delay) | (1 << BH_Unwritten))
1688 /*
1689 * mpage_add_bh_to_extent - try to add one more block to extent of blocks
1690 *
1691 * @mpd->lbh - extent of blocks
1692 * @logical - logical number of the block in the file
1693 * @bh - bh of the block (used to access block's state)
1694 *
1695 * the function is used to collect contig. blocks in same state
1696 */
1700 {
1701 sector_t next;
1704 /*
1705 * XXX Don't go larger than mballoc is willing to allocate
1706 * This is a stopgap solution. We eventually need to fold
1707 * mpage_da_submit_io() into this function and then call
1708 * ext4_map_blocks() multiple times in a loop
1709 */
1713 /* check if thereserved journal credits might overflow */
1716 /*
1717 * With non-extent format we are limited by the journal
1718 * credit available. Total credit needed to insert
1719 * nrblocks contiguous blocks is dependent on the
1720 * nrblocks. So limit nrblocks.
1721 */
1724 EXT4_MAX_TRANS_DATA) {
1725 /*
1726 * Adding the new buffer_head would make it cross the
1727 * allowed limit for which we have journal credit
1728 * reserved. So limit the new bh->b_size
1729 */
1732 /* we will do mpage_da_submit_io in the next loop */
1733 }
1734 }
1735 /*
1736 * First block in the extent
1737 */
1743 }
1746 /*
1747 * Can we merge the block to our big extent?
1748 */
1752 }
1754 flush_it:
1755 /*
1756 * We couldn't merge the block to our extent, so we
1757 * need to flush current extent and start new one
1758 */
1761 }
1764 {
1766 }
1768 /*
1769 * This function is grabs code from the very beginning of
1770 * ext4_map_blocks, but assumes that the caller is from delayed write
1771 * time. This function looks up the requested blocks and sets the
1772 * buffer delay bit under the protection of i_data_sem.
1773 */
1777 {
1788 /*
1789 * Try to see if we can get the block without requesting a new
1790 * file system block.
1791 */
1794 /*
1795 * We will soon create blocks for this page, and let
1796 * us pretend as if the blocks aren't allocated yet.
1797 * In case of clusters, we have to handle the work
1798 * of mapping from cluster so that the reserved space
1799 * is calculated properly.
1800 */
1807 else
1811 /*
1812 * XXX: __block_prepare_write() unmaps passed block,
1813 * is it OK?
1814 */
1815 /* If the block was allocated from previously allocated cluster,
1816 * then we dont need to reserve it again. */
1820 /* not enough space to reserve */
1822 }
1828 /* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
1829 * and it should not appear on the bh->b_state.
1830 */
1836 }
1838 out_unlock:
1842 }
1844 /*
1845 * This is a special get_blocks_t callback which is used by
1846 * ext4_da_write_begin(). It will either return mapped block or
1847 * reserve space for a single block.
1848 *
1849 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
1850 * We also have b_blocknr = -1 and b_bdev initialized properly
1851 *
1852 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
1853 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
1854 * initialized properly.
1855 */
1858 {
1868 /*
1869 * first, we need to know whether the block is allocated already
1870 * preallocated blocks are unmapped but should treated
1871 * the same as allocated blocks.
1872 */
1881 /* A delayed write to unwritten bh should be marked
1882 * new and mapped. Mapped ensures that we don't do
1883 * get_block multiple times when we write to the same
1884 * offset and new ensures that we do proper zero out
1885 * for partial write.
1886 */
1889 }
1891 }
1893 /*
1894 * This function is used as a standard get_block_t calback function
1895 * when there is no desire to allocate any blocks. It is used as a
1896 * callback function for block_write_begin() and block_write_full_page().
1897 * These functions should only try to map a single block at a time.
1898 *
1899 * Since this function doesn't do block allocations even if the caller
1900 * requests it by passing in create=1, it is critically important that
1901 * any caller checks to make sure that any buffer heads are returned
1902 * by this function are either all already mapped or marked for
1903 * delayed allocation before calling block_write_full_page(). Otherwise,
1904 * b_blocknr could be left unitialized, and the page write functions will
1905 * be taken by surprise.
1906 */
1909 {
1912 }
1915 {
1918 }
1921 {
1924 }
1928 {
1950 }
1953 }
1954 /* As soon as we unlock the page, it can go away, but we have
1955 * references to buffers so we are safe */
1962 }
1973 do_journal_get_write_access);
1976 write_end_fn);
1977 }
1989 out:
1992 }
1994 /*
1995 * Note that we don't need to start a transaction unless we're journaling data
1996 * because we should have holes filled from ext4_page_mkwrite(). We even don't
1997 * need to file the inode to the transaction's list in ordered mode because if
1998 * we are writing back data added by write(), the inode is already there and if
1999 * we are writing back data modified via mmap(), no one guarantees in which
2000 * transaction the data will hit the disk. In case we are journaling data, we
2001 * cannot start transaction directly because transaction start ranks above page
2002 * lock so we have to do some magic.
2003 *
2004 * This function can get called via...
2005 * - ext4_da_writepages after taking page lock (have journal handle)
2006 * - journal_submit_inode_data_buffers (no journal handle)
2007 * - shrink_page_list via the kswapd/direct reclaim (no journal handle)
2008 * - grab_page_cache when doing write_begin (have journal handle)
2009 *
2010 * We don't do any block allocation in this function. If we have page with
2011 * multiple blocks we need to write those buffer_heads that are mapped. This
2012 * is important for mmaped based write. So if we do with blocksize 1K
2013 * truncate(f, 1024);
2014 * a = mmap(f, 0, 4096);
2015 * a[0] = 'a';
2016 * truncate(f, 4096);
2017 * we have in the page first buffer_head mapped via page_mkwrite call back
2018 * but other buffer_heads would be unmapped but dirty (dirty done via the
2019 * do_wp_page). So writepage should write the first block. If we modify
2020 * the mmap area beyond 1024 we will again get a page_fault and the
2021 * page_mkwrite callback will do the block allocation and mark the
2022 * buffer_heads mapped.
2023 *
2024 * We redirty the page if we have any buffer_heads that is either delay or
2025 * unwritten in the page.
2026 *
2027 * We can get recursively called as show below.
2028 *
2029 * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
2030 * ext4_writepage()
2031 *
2032 * But since we don't do any block allocation we should not deadlock.
2033 * Page also have the dirty flag cleared so we don't get recurive page_lock.
2034 */
2037 {
2039 loff_t size;
2048 else
2051 /*
2052 * If the page does not have buffers (for whatever reason),
2053 * try to create them using __block_write_begin. If this
2054 * fails, redirty the page and move on.
2055 */
2058 noalloc_get_block_write)) {
2059 redirty_page:
2063 }
2065 }
2068 ext4_bh_delay_or_unwritten)) {
2069 /*
2070 * We don't want to do block allocation, so redirty
2071 * the page and return. We may reach here when we do
2072 * a journal commit via journal_submit_inode_data_buffers.
2073 * We can also reach here via shrink_page_list but it
2074 * should never be for direct reclaim so warn if that
2075 * happens
2076 */
2078 PF_MEMALLOC);
2080 }
2082 /* now mark the buffer_heads as dirty and uptodate */
2086 /*
2087 * It's mmapped pagecache. Add buffers and journal it. There
2088 * doesn't seem much point in redirtying the page here.
2089 */
2098 wbc);
2101 }
2103 /*
2104 * This is called via ext4_da_writepages() to
2105 * calculate the total number of credits to reserve to fit
2106 * a single extent allocation into a single transaction,
2107 * ext4_da_writpeages() will loop calling this before
2108 * the block allocation.
2109 */
2112 {
2115 /*
2116 * With non-extent format the journal credit needed to
2117 * insert nrblocks contiguous block is dependent on
2118 * number of contiguous block. So we will limit
2119 * number of contiguous block to a sane value
2120 */
2126 }
2128 /*
2129 * write_cache_pages_da - walk the list of dirty pages of the given
2130 * address space and accumulate pages that need writing, and call
2131 * mpage_da_map_and_submit to map a single contiguous memory region
2132 * and then write them.
2133 */
2139 {
2144 sector_t logical;
2158 else
2171 /*
2172 * At this point, the page may be truncated or
2173 * invalidated (changing page->mapping to NULL), or
2174 * even swizzled back from swapper_space to tmpfs file
2175 * mapping. However, page->index will not change
2176 * because we have a reference on the page.
2177 */
2183 /*
2184 * If we can't merge this page, and we have
2185 * accumulated an contiguous region, write it
2186 */
2191 }
2195 /*
2196 * If the page is no longer dirty, or its
2197 * mapping no longer corresponds to inode we
2198 * are writing (which means it has been
2199 * truncated or invalidated), or the page is
2200 * already under writeback and we are not
2201 * doing a data integrity writeback, skip the page
2202 */
2209 }
2214 /*
2215 * If we have inline data and arrive here, it means that
2216 * we will soon create the block for the 1st page, so
2217 * we'd better clear the inline data here.
2218 */
2221 EXT4_STATE_MAY_INLINE_DATA));
2223 }
2233 PAGE_CACHE_SIZE,
2238 /*
2239 * Page with regular buffer heads,
2240 * just add all dirty ones
2241 */
2246 /*
2247 * We need to try to allocate
2248 * unmapped blocks in the same page.
2249 * Otherwise we won't make progress
2250 * with the page in ext4_writepage
2251 */
2259 /*
2260 * mapped dirty buffer. We need
2261 * to update the b_state
2262 * because we look at b_state
2263 * in mpage_da_map_blocks. We
2264 * don't update b_size because
2265 * if we find an unmapped
2266 * buffer_head later we need to
2267 * use the b_state flag of that
2268 * buffer_head.
2269 */
2272 }
2273 logical++;
2275 }
2278 nr_to_write--;
2281 /*
2282 * We stop writing back only if we are
2283 * not doing integrity sync. In case of
2284 * integrity sync we have to keep going
2285 * because someone may be concurrently
2286 * dirtying pages, and we might have
2287 * synced a lot of newly appeared dirty
2288 * pages, but have not synced all of the
2289 * old dirty pages.
2290 */
2292 }
2293 }
2296 }
2298 ret_extent_tail:
2300 out:
2304 }
2309 {
2310 pgoff_t index;
2323 pgoff_t end;
2328 /*
2329 * No pages to write? This is mainly a kludge to avoid starting
2330 * a transaction for special inodes like journal inode on last iput()
2331 * because that could violate lock ordering on umount
2332 */
2336 /*
2337 * If the filesystem has aborted, it is read-only, so return
2338 * right away instead of dumping stack traces later on that
2339 * will obscure the real source of the problem. We test
2340 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2341 * the latter could be true if the filesystem is mounted
2342 * read-only, and in that case, ext4_da_writepages should
2343 * *never* be called, so if that ever happens, we would want
2344 * the stack trace.
2345 */
2364 }
2366 /*
2367 * This works around two forms of stupidity. The first is in
2368 * the writeback code, which caps the maximum number of pages
2369 * written to be 1024 pages. This is wrong on multiple
2370 * levels; different architectues have a different page size,
2371 * which changes the maximum amount of data which gets
2372 * written. Secondly, 4 megabytes is way too small. XFS
2373 * forces this value to be 16 megabytes by multiplying
2374 * nr_to_write parameter by four, and then relies on its
2375 * allocator to allocate larger extents to make them
2376 * contiguous. Unfortunately this brings us to the second
2377 * stupidity, which is that ext4's mballoc code only allocates
2378 * at most 2048 blocks. So we force contiguous writes up to
2379 * the number of dirty blocks in the inode, or
2380 * sbi->max_writeback_mb_bump whichever is smaller.
2381 */
2386 else
2390 max_pages);
2397 }
2399 retry:
2406 /*
2407 * we insert one extent at a time. So we need
2408 * credit needed for single extent allocation.
2409 * journalled mode is currently not supported
2410 * by delalloc
2411 */
2415 /* start a new transaction*/
2424 }
2426 /*
2427 * Now call write_cache_pages_da() to find the next
2428 * contiguous region of logical blocks that need
2429 * blocks to be allocated by ext4 and submit them.
2430 */
2433 /*
2434 * If we have a contiguous extent of pages and we
2435 * haven't done the I/O yet, map the blocks and submit
2436 * them for I/O.
2437 */
2441 }
2448 /* commit the transaction which would
2449 * free blocks released in the transaction
2450 * and try again
2451 */
2455 /*
2456 * Got one extent now try with rest of the pages.
2457 * If mpd.retval is set -EIO, journal is aborted.
2458 * So we don't need to write any more.
2459 */
2464 /*
2465 * There is no more writeout needed
2466 * or we requested for a noblocking writeout
2467 * and we found the device congested
2468 */
2470 }
2478 }
2480 /* Update index */
2483 /*
2484 * set the writeback_index so that range_cyclic
2485 * mode will write it back later
2486 */
2489 out_writepages:
2494 }
2497 {
2501 /*
2502 * switch to non delalloc mode if we are running low
2503 * on free block. The free block accounting via percpu
2504 * counters can get slightly wrong with percpu_counter_batch getting
2505 * accumulated on each CPU without updating global counters
2506 * Delalloc need an accurate free block accounting. So switch
2507 * to non delalloc when we are near to error range.
2508 */
2512 /*
2513 * Start pushing delalloc when 1/2 of free blocks are dirty.
2514 */
2520 }
2524 /*
2525 * free block count is less than 150% of dirty blocks
2526 * or free blocks is less than watermark
2527 */
2529 }
2531 }
2536 {
2539 pgoff_t index;
2549 }
2562 }
2563 }
2565 retry:
2566 /*
2567 * With delayed allocation, we don't log the i_disksize update
2568 * if there is delayed block allocation. But we still need
2569 * to journalling the i_disksize update if writes to the end
2570 * of file which has an already mapped buffer.
2571 */
2576 }
2577 /* We cannot recurse into the filesystem as the transaction is already
2578 * started */
2586 }
2594 /*
2595 * block_write_begin may have instantiated a few blocks
2596 * outside i_size. Trim these off again. Don't need
2597 * i_size_read because we hold i_mutex.
2598 */
2601 }
2605 out:
2607 }
2609 /*
2610 * Check if we should update i_disksize
2611 * when write to the end of file but not require block allocation
2612 */
2615 {
2630 }
2636 {
2640 loff_t new_i_size;
2654 }
2655 }
2661 /*
2662 * generic_write_end() will run mark_inode_dirty() if i_size
2663 * changes. So let's piggyback the i_disksize mark_inode_dirty
2664 * into that.
2665 */
2674 /* We need to mark inode dirty even if
2675 * new_i_size is less that inode->i_size
2676 * bu greater than i_disksize.(hint delalloc)
2677 */
2679 }
2680 }
2686 page);
2687 else
2699 }
2702 {
2703 /*
2704 * Drop reserved blocks
2705 */
2712 out:
2716 }
2718 /*
2719 * Force all delayed allocation blocks to be allocated for a given inode.
2720 */
2722 {
2729 /*
2730 * We do something simple for now. The filemap_flush() will
2731 * also start triggering a write of the data blocks, which is
2732 * not strictly speaking necessary (and for users of
2733 * laptop_mode, not even desirable). However, to do otherwise
2734 * would require replicating code paths in:
2735 *
2736 * ext4_da_writepages() ->
2737 * write_cache_pages() ---> (via passed in callback function)
2738 * __mpage_da_writepage() -->
2739 * mpage_add_bh_to_extent()
2740 * mpage_da_map_blocks()
2741 *
2742 * The problem is that write_cache_pages(), located in
2743 * mm/page-writeback.c, marks pages clean in preparation for
2744 * doing I/O, which is not desirable if we're not planning on
2745 * doing I/O at all.
2746 *
2747 * We could call write_cache_pages(), and then redirty all of
2748 * the pages by calling redirty_page_for_writepage() but that
2749 * would be ugly in the extreme. So instead we would need to
2750 * replicate parts of the code in the above functions,
2751 * simplifying them because we wouldn't actually intend to
2752 * write out the pages, but rather only collect contiguous
2753 * logical block extents, call the multi-block allocator, and
2754 * then update the buffer heads with the block allocations.
2755 *
2756 * For now, though, we'll cheat by calling filemap_flush(),
2757 * which will map the blocks, and start the I/O, but not
2758 * actually wait for the I/O to complete.
2759 */
2761 }
2763 /*
2764 * bmap() is special. It gets used by applications such as lilo and by
2765 * the swapper to find the on-disk block of a specific piece of data.
2766 *
2767 * Naturally, this is dangerous if the block concerned is still in the
2768 * journal. If somebody makes a swapfile on an ext4 data-journaling
2769 * filesystem and enables swap, then they may get a nasty shock when the
2770 * data getting swapped to that swapfile suddenly gets overwritten by
2771 * the original zero's written out previously to the journal and
2772 * awaiting writeback in the kernel's buffer cache.
2773 *
2774 * So, if we see any bmap calls here on a modified, data-journaled file,
2775 * take extra steps to flush any blocks which might be in the cache.
2776 */
2778 {
2783 /*
2784 * We can get here for an inline file via the FIBMAP ioctl
2785 */
2791 /*
2792 * With delalloc we want to sync the file
2793 * so that we can make sure we allocate
2794 * blocks for file
2795 */
2797 }
2801 /*
2802 * This is a REALLY heavyweight approach, but the use of
2803 * bmap on dirty files is expected to be extremely rare:
2804 * only if we run lilo or swapon on a freshly made file
2805 * do we expect this to happen.
2806 *
2807 * (bmap requires CAP_SYS_RAWIO so this does not
2808 * represent an unprivileged user DOS attack --- we'd be
2809 * in trouble if mortal users could trigger this path at
2810 * will.)
2811 *
2812 * NB. EXT4_STATE_JDATA is not set on files other than
2813 * regular files. If somebody wants to bmap a directory
2814 * or symlink and gets confused because the buffer
2815 * hasn't yet been flushed to disk, they deserve
2816 * everything they get.
2817 */
2827 }
2830 }
2833 {
2846 }
2848 static int
2851 {
2854 /* If the file has inline data, no need to do readpages. */
2859 }
2862 {
2875 }
2879 }
2882 {
2885 /*
2886 * free any io_end structure allocated for buffers to be discarded
2887 */
2891 /* No journalling happens on data buffers when this function is used */
2895 }
2899 {
2904 /*
2905 * If it's a full truncate we just forget about the pending dirtying
2906 */
2911 }
2913 /* Wrapper for aops... */
2916 {
2918 }
2921 {
2931 else
2933 }
2935 /*
2936 * ext4_get_block used when preparing for a DIO write or buffer write.
2937 * We allocate an uinitialized extent if blocks haven't been allocated.
2938 * The extent will be converted to initialized after the IO is complete.
2939 */
2942 {
2946 EXT4_GET_BLOCKS_IO_CREATE_EXT);
2947 }
2951 {
2955 EXT4_GET_BLOCKS_NO_LOCK);
2956 }
2961 {
2965 /* if not async direct IO or dio with 0 bytes write, just return */
2972 size);
2976 /* if not aio dio with unwritten extents, just free io and return */
2979 out:
2984 }
2991 }
2994 }
2997 {
3010 }
3012 /*
3013 * It may be over-defensive here to check EXT4_IO_END_UNWRITTEN now,
3014 * but being more careful is always safe for the future change.
3015 */
3019 out:
3024 }
3027 {
3033 retry:
3039 }
3042 /*
3043 * We need to hold a reference to the page to make sure it
3044 * doesn't get evicted before ext4_end_io_work() has a chance
3045 * to convert the extent from written to unwritten.
3046 */
3053 }
3055 /*
3056 * For ext4 extent files, ext4 will do direct-io write to holes,
3057 * preallocated extents, and those write extend the file, no need to
3058 * fall back to buffered IO.
3059 *
3060 * For holes, we fallocate those blocks, mark them as uninitialized
3061 * If those blocks were preallocated, we mark sure they are split, but
3062 * still keep the range to write as uninitialized.
3063 *
3064 * The unwritten extents will be converted to written when DIO is completed.
3065 * For async direct IO, since the IO may still pending when return, we
3066 * set up an end_io call back function, which will do the conversion
3067 * when async direct IO completed.
3068 *
3069 * If the O_DIRECT write will extend the file then add this inode to the
3070 * orphan list. So recovery will truncate it back to the original size
3071 * if the machine crashes during the write.
3072 *
3073 */
3077 {
3080 ssize_t ret;
3087 /* Use the old path for reads and writes beyond i_size. */
3093 /* If we do a overwrite dio, i_mutex locking can be released */
3100 }
3102 /*
3103 * We could direct write to holes and fallocate.
3104 *
3105 * Allocated blocks to fill the hole are marked as
3106 * uninitialized to prevent parallel buffered read to expose
3107 * the stale data before DIO complete the data IO.
3108 *
3109 * As to previously fallocated extents, ext4 get_block will
3110 * just simply mark the buffer mapped but still keep the
3111 * extents uninitialized.
3112 *
3113 * For non AIO case, we will convert those unwritten extents
3114 * to written after return back from blockdev_direct_IO.
3115 *
3116 * For async DIO, the conversion needs to be deferred when the
3117 * IO is completed. The ext4 end_io callback function will be
3118 * called to take care of the conversion work. Here for async
3119 * case, we allocate an io_end structure to hook to the iocb.
3120 */
3128 }
3131 /*
3132 * we save the io structure for current async direct
3133 * IO, so that later ext4_map_blocks() could flag the
3134 * io structure whether there is a unwritten extents
3135 * needs to be converted when IO is completed.
3136 */
3138 }
3145 }
3149 get_block_func,
3150 ext4_end_io_dio,
3151 NULL,
3152 dio_flags);
3156 /*
3157 * The io_end structure takes a reference to the inode, that
3158 * structure needs to be destroyed and the reference to the
3159 * inode need to be dropped, when IO is complete, even with 0
3160 * byte write, or failed.
3161 *
3162 * In the successful AIO DIO case, the io_end structure will
3163 * be destroyed and the reference to the inode will be dropped
3164 * after the end_io call back function is called.
3165 *
3166 * In the case there is 0 byte write, or error case, since VFS
3167 * direct IO won't invoke the end_io call back function, we
3168 * need to free the end_io structure here.
3169 */
3174 EXT4_STATE_DIO_UNWRITTEN)) {
3176 /*
3177 * for non AIO case, since the IO is already
3178 * completed, we could do the conversion right here
3179 */
3185 }
3187 retake_lock:
3188 /* take i_mutex locking again if we do a ovewrite dio */
3193 }
3196 }
3201 {
3204 ssize_t ret;
3206 /*
3207 * If we are doing data journalling we don't support O_DIRECT
3208 */
3212 /* Let buffer I/O handle the inline data case. */
3219 else
3224 }
3226 /*
3227 * Pages can be marked dirty completely asynchronously from ext4's journalling
3228 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
3229 * much here because ->set_page_dirty is called under VFS locks. The page is
3230 * not necessarily locked.
3231 *
3232 * We cannot just dirty the page and leave attached buffers clean, because the
3233 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
3234 * or jbddirty because all the journalling code will explode.
3235 *
3236 * So what we do is to mark the page "pending dirty" and next time writepage
3237 * is called, propagate that into the buffers appropriately.
3238 */
3240 {
3243 }
3258 };
3273 };
3288 };
3304 };
3307 {
3312 else
3318 else
3326 }
3327 }
3330 /*
3331 * ext4_discard_partial_page_buffers()
3332 * Wrapper function for ext4_discard_partial_page_buffers_no_lock.
3333 * This function finds and locks the page containing the offset
3334 * "from" and passes it to ext4_discard_partial_page_buffers_no_lock.
3335 * Calling functions that already have the page locked should call
3336 * ext4_discard_partial_page_buffers_no_lock directly.
3337 */
3341 {
3357 }
3359 /*
3360 * ext4_discard_partial_page_buffers_no_lock()
3361 * Zeros a page range of length 'length' starting from offset 'from'.
3362 * Buffer heads that correspond to the block aligned regions of the
3363 * zeroed range will be unmapped. Unblock aligned regions
3364 * will have the corresponding buffer head mapped if needed so that
3365 * that region of the page can be updated with the partial zero out.
3366 *
3367 * This function assumes that the page has already been locked. The
3368 * The range to be discarded must be contained with in the given page.
3369 * If the specified range exceeds the end of the page it will be shortened
3370 * to the end of the page that corresponds to 'from'. This function is
3371 * appropriate for updating a page and it buffer heads to be unmapped and
3372 * zeroed for blocks that have been either released, or are going to be
3373 * released.
3374 *
3375 * handle: The journal handle
3376 * inode: The files inode
3377 * page: A locked page that contains the offset "from"
3378 * from: The starting byte offset (from the beginning of the file)
3379 * to begin discarding
3380 * len: The length of bytes to discard
3381 * flags: Optional flags that may be used:
3382 *
3383 * EXT4_DISCARD_PARTIAL_PG_ZERO_UNMAPPED
3384 * Only zero the regions of the page whose buffer heads
3385 * have already been unmapped. This flag is appropriate
3386 * for updating the contents of a page whose blocks may
3387 * have already been released, and we only want to zero
3388 * out the regions that correspond to those released blocks.
3389 *
3390 * Returns zero on success or negative on failure.
3391 */
3395 {
3399 ext4_lblk_t iblock;
3409 /*
3410 * correct length if it does not fall between
3411 * 'from' and the end of the page
3412 */
3421 /* Find the buffer that contains "offset" */
3426 iblock++;
3428 }
3436 /* The length of space left to zero and unmap */
3439 /* The length of space until the end of the block */
3442 /*
3443 * Do not unmap or zero past end of block
3444 * for this buffer head
3445 */
3450 /*
3451 * Skip this buffer head if we are only zeroing unampped
3452 * regions of the page
3453 */
3458 /* If the range is block aligned, unmap */
3471 }
3473 /*
3474 * If this block is not completely contained in the range
3475 * to be discarded, then it is not going to be released. Because
3476 * we need to keep this block, we need to make sure this part
3477 * of the page is uptodate before we modify it by writeing
3478 * partial zeros on it.
3479 */
3481 /*
3482 * Buffer head must be mapped before we can read
3483 * from the block
3484 */
3487 /* unmapped? It's a hole - nothing to do */
3491 }
3492 }
3494 /* Ok, it's mapped. Make sure it's up-to-date */
3502 /* Uhhuh. Read error. Complain and punt.*/
3505 }
3512 }
3523 next:
3525 iblock++;
3527 }
3530 }
3533 {
3541 }
3543 /*
3544 * ext4_punch_hole: punches a hole in a file by releaseing the blocks
3545 * associated with the given offset and length
3546 *
3547 * @inode: File inode
3548 * @offset: The offset where the hole will begin
3549 * @len: The length of the hole
3550 *
3551 * Returns: 0 on success or negative on failure
3552 */
3555 {
3561 /* TODO: Add support for non extent hole punching */
3563 }
3566 /* TODO: Add support for bigalloc file systems */
3568 }
3571 }
3573 /*
3574 * ext4_truncate()
3575 *
3576 * We block out ext4_get_block() block instantiations across the entire
3577 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3578 * simultaneously on behalf of the same inode.
3579 *
3580 * As we work through the truncate and commit bits of it to the journal there
3581 * is one core, guiding principle: the file's tree must always be consistent on
3582 * disk. We must be able to restart the truncate after a crash.
3583 *
3584 * The file's tree may be transiently inconsistent in memory (although it
3585 * probably isn't), but whenever we close off and commit a journal transaction,
3586 * the contents of (the filesystem + the journal) must be consistent and
3587 * restartable. It's pretty simple, really: bottom up, right to left (although
3588 * left-to-right works OK too).
3589 *
3590 * Note that at recovery time, journal replay occurs *before* the restart of
3591 * truncate against the orphan inode list.
3592 *
3593 * The committed inode has the new, desired i_size (which is the same as
3594 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see
3595 * that this inode's truncate did not complete and it will again call
3596 * ext4_truncate() to have another go. So there will be instantiated blocks
3597 * to the right of the truncation point in a crashed ext4 filesystem. But
3598 * that's fine - as long as they are linked from the inode, the post-crash
3599 * ext4_truncate() run will find them and release them.
3600 */
3602 {
3619 }
3623 else
3627 }
3629 /*
3630 * ext4_get_inode_loc returns with an extra refcount against the inode's
3631 * underlying buffer_head on success. If 'in_mem' is true, we have all
3632 * data in memory that is needed to recreate the on-disk version of this
3633 * inode.
3634 */
3637 {
3641 ext4_fsblk_t block;
3653 /*
3654 * Figure out the offset within the block group inode table
3655 */
3667 }
3671 /*
3672 * If the buffer has the write error flag, we have failed
3673 * to write out another inode in the same block. In this
3674 * case, we don't have to read the block because we may
3675 * read the old inode data successfully.
3676 */
3681 /* someone brought it uptodate while we waited */
3684 }
3686 /*
3687 * If we have all information of the inode in memory and this
3688 * is the only valid inode in the block, we need not read the
3689 * block.
3690 */
3697 /* Is the inode bitmap in cache? */
3702 /*
3703 * If the inode bitmap isn't in cache then the
3704 * optimisation may end up performing two reads instead
3705 * of one, so skip it.
3706 */
3710 }
3716 }
3719 /* all other inodes are free, so skip I/O */
3724 }
3725 }
3727 make_io:
3728 /*
3729 * If we need to do any I/O, try to pre-readahead extra
3730 * blocks from the inode table.
3731 */
3737 /* s_inode_readahead_blks is always a power of 2 */
3750 }
3752 /*
3753 * There are other valid inodes in the buffer, this inode
3754 * has in-inode xattrs, or we don't have this inode in memory.
3755 * Read the block from disk.
3756 */
3767 }
3768 }
3769 has_buffer:
3772 }
3775 {
3776 /* We have all inode data except xattrs in memory here. */
3779 }
3782 {
3796 }
3798 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3800 {
3809 EXT4_DIRSYNC_FL);
3821 }
3825 {
3826 blkcnt_t i_blocks ;
3831 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
3832 /* we are using combined 48 bit field */
3836 /* i_blocks represent file system block size */
3840 }
3843 }
3844 }
3849 {
3857 }
3860 {
3868 uid_t i_uid;
3869 gid_t i_gid;
3894 }
3898 /* Precompute checksum seed for inode metadata */
3900 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
3902 __u32 csum;
3909 }
3915 }
3923 }
3932 /* We now have enough fields to check if the inode was active or not.
3933 * This is needed because nfsd might try to access dead inodes
3934 * the test is that same one that e2fsck uses
3935 * NeilBrown 1999oct15
3936 */
3940 /* this inode is deleted */
3943 }
3944 /* The only unlinked inodes we let through here have
3945 * valid i_mode and are being read by the orphan
3946 * recovery code: that's fine, we're about to complete
3947 * the process of deleting those. */
3948 }
3957 #ifdef CONFIG_QUOTA
3959 #endif
3963 /*
3964 * NOTE! The in-memory inode i_data array is in little-endian order
3965 * even on big-endian machines: we do NOT byteswap the block numbers!
3966 */
3971 /*
3972 * Set transaction id's of transactions that have to be committed
3973 * to finish f[data]sync. We set them to currently running transaction
3974 * as we cannot be sure that the inode or some of its metadata isn't
3975 * part of the transaction - the inode could have been reclaimed and
3976 * now it is reread from disk.
3977 */
3980 tid_t tid;
3985 else
3989 else
3994 }
3998 /* The extra space is currently unused. Use it. */
4000 EXT4_GOOD_OLD_INODE_SIZE;
4003 }
4004 }
4016 }
4030 /* Validate extent which is part of inode */
4035 /* Validate block references which are part of inode */
4037 }
4038 }
4057 }
4064 else
4071 }
4077 bad_inode:
4081 }
4086 {
4092 /*
4093 * i_blocks can be represented in a 32 bit variable
4094 * as multiple of 512 bytes
4095 */
4100 }
4105 /*
4106 * i_blocks can be represented in a 48 bit variable
4107 * as multiple of 512 bytes
4108 */
4114 /* i_block is stored in file system block size */
4118 }
4120 }
4122 /*
4123 * Post the struct inode info into an on-disk inode location in the
4124 * buffer-cache. This gobbles the caller's reference to the
4125 * buffer_head in the inode location struct.
4126 *
4127 * The caller must have write access to iloc->bh.
4128 */
4132 {
4138 uid_t i_uid;
4139 gid_t i_gid;
4141 /* For fields not not tracking in the in-memory inode,
4142 * initialise them to zero for new inodes. */
4153 /*
4154 * Fix up interoperability with old kernels. Otherwise, old inodes get
4155 * re-used with the upper 16 bits of the uid/gid intact
4156 */
4165 }
4171 }
4191 }
4195 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4198 /* If this is the first large file
4199 * created, add a flag to the superblock.
4200 */
4207 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4210 }
4211 }
4223 }
4227 }
4235 }
4246 out_brelse:
4250 }
4252 /*
4253 * ext4_write_inode()
4254 *
4255 * We are called from a few places:
4256 *
4257 * - Within generic_file_write() for O_SYNC files.
4258 * Here, there will be no transaction running. We wait for any running
4259 * transaction to commit.
4260 *
4261 * - Within sys_sync(), kupdate and such.
4262 * We wait on commit, if tol to.
4263 *
4264 * - Within prune_icache() (PF_MEMALLOC == true)
4265 * Here we simply return. We can't afford to block kswapd on the
4266 * journal commit.
4267 *
4268 * In all cases it is actually safe for us to return without doing anything,
4269 * because the inode has been copied into a raw inode buffer in
4270 * ext4_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
4271 * knfsd.
4272 *
4273 * Note that we are absolutely dependent upon all inode dirtiers doing the
4274 * right thing: they *must* call mark_inode_dirty() after dirtying info in
4275 * which we are interested.
4276 *
4277 * It would be a bug for them to not do this. The code:
4278 *
4279 * mark_inode_dirty(inode)
4280 * stuff();
4281 * inode->i_size = expr;
4282 *
4283 * is in error because a kswapd-driven write_inode() could occur while
4284 * `stuff()' is running, and the new i_size will be lost. Plus the inode
4285 * will no longer be on the superblock's dirty inode list.
4286 */
4288 {
4299 }
4317 }
4319 }
4321 }
4323 /*
4324 * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
4325 * buffers that are attached to a page stradding i_size and are undergoing
4326 * commit. In that case we have to wait for commit to finish and try again.
4327 */
4329 {
4337 /*
4338 * All buffers in the last page remain valid? Then there's nothing to
4339 * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
4340 * blocksize case
4341 */
4361 }
4362 }
4364 /*
4365 * ext4_setattr()
4366 *
4367 * Called from notify_change.
4368 *
4369 * We want to trap VFS attempts to truncate the file as soon as
4370 * possible. In particular, we want to make sure that when the VFS
4371 * shrinks i_size, we put the inode on the orphan list and modify
4372 * i_disksize immediately, so that during the subsequent flushing of
4373 * dirty pages and freeing of disk blocks, we can guarantee that any
4374 * commit will leave the blocks being flushed in an unused state on
4375 * disk. (On recovery, the inode will get truncated and the blocks will
4376 * be freed, so we have a strong guarantee that no future commit will
4377 * leave these blocks visible to the user.)
4378 *
4379 * Another thing we have to assure is that if we are in ordered mode
4380 * and inode is still attached to the committing transaction, we must
4381 * we start writeout of all the dirty pages which are being truncated.
4382 * This way we are sure that all the data written in the previous
4383 * transaction are already on disk (truncate waits for pages under
4384 * writeback).
4385 *
4386 * Called with inode->i_mutex down.
4387 */
4389 {
4405 /* (user+group)*(old+new) structure, inode write (sb,
4406 * inode block, ? - but truncate inode update has it) */
4412 }
4417 }
4418 /* Update corresponding info in inode so that everything is in
4419 * one transaction */
4426 }
4435 }
4436 }
4447 }
4451 }
4462 /* Do as much error cleanup as possible */
4467 }
4472 }
4473 }
4474 }
4481 /*
4482 * Blocks are going to be removed from the inode. Wait
4483 * for dio in flight. Temporarily disable
4484 * dioread_nolock to prevent livelock.
4485 */
4493 }
4494 /*
4495 * Truncate pagecache after we've waited for commit
4496 * in data=journal mode to make pages freeable.
4497 */
4499 }
4501 }
4506 }
4508 /*
4509 * If the call to ext4_truncate failed to get a transaction handle at
4510 * all, we need to clean up the in-core orphan list manually.
4511 */
4518 err_out:
4523 }
4527 {
4534 /*
4535 * We can't update i_blocks if the block allocation is delayed
4536 * otherwise in the case of system crash before the real block
4537 * allocation is done, we will have i_blocks inconsistent with
4538 * on-disk file blocks.
4539 * We always keep i_blocks updated together with real
4540 * allocation. But to not confuse with user, stat
4541 * will return the blocks that include the delayed allocation
4542 * blocks for this file.
4543 */
4549 }
4552 {
4556 }
4558 /*
4559 * Account for index blocks, block groups bitmaps and block group
4560 * descriptor blocks if modify datablocks and index blocks
4561 * worse case, the indexs blocks spread over different block groups
4562 *
4563 * If datablocks are discontiguous, they are possible to spread over
4564 * different block groups too. If they are contiguous, with flexbg,
4565 * they could still across block group boundary.
4566 *
4567 * Also account for superblock, inode, quota and xattr blocks
4568 */
4570 {
4576 /*
4577 * How many index blocks need to touch to modify nrblocks?
4578 * The "Chunk" flag indicating whether the nrblocks is
4579 * physically contiguous on disk
4580 *
4581 * For Direct IO and fallocate, they calls get_block to allocate
4582 * one single extent at a time, so they could set the "Chunk" flag
4583 */
4588 /*
4589 * Now let's see how many group bitmaps and group descriptors need
4590 * to account
4591 */
4595 else
4604 /* bitmaps and block group descriptor blocks */
4607 /* Blocks for super block, inode, quota and xattr blocks */
4611 }
4613 /*
4614 * Calculate the total number of credits to reserve to fit
4615 * the modification of a single pages into a single transaction,
4616 * which may include multiple chunks of block allocations.
4617 *
4618 * This could be called via ext4_write_begin()
4619 *
4620 * We need to consider the worse case, when
4621 * one new block per extent.
4622 */
4624 {
4630 /* Account for data blocks for journalled mode */
4634 }
4636 /*
4637 * Calculate the journal credits for a chunk of data modification.
4638 *
4639 * This is called from DIO, fallocate or whoever calling
4640 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4641 *
4642 * journal buffers for data blocks are not included here, as DIO
4643 * and fallocate do no need to journal data buffers.
4644 */
4646 {
4648 }
4650 /*
4651 * The caller must have previously called ext4_reserve_inode_write().
4652 * Give this, we know that the caller already has write access to iloc->bh.
4653 */
4656 {
4662 /* the do_update_inode consumes one bh->b_count */
4665 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4669 }
4671 /*
4672 * On success, We end up with an outstanding reference count against
4673 * iloc->bh. This _must_ be cleaned up later.
4674 */
4676 int
4679 {
4689 }
4690 }
4693 }
4695 /*
4696 * Expand an inode by new_extra_isize bytes.
4697 * Returns 0 on success or negative error number on failure.
4698 */
4703 {
4714 /* No extended attributes present */
4718 new_extra_isize);
4721 }
4723 /* try to expand with EAs present */
4726 }
4728 /*
4729 * What we do here is to mark the in-core inode as clean with respect to inode
4730 * dirtiness (it may still be data-dirty).
4731 * This means that the in-core inode may be reaped by prune_icache
4732 * without having to perform any I/O. This is a very good thing,
4733 * because *any* task may call prune_icache - even ones which
4734 * have a transaction open against a different journal.
4735 *
4736 * Is this cheating? Not really. Sure, we haven't written the
4737 * inode out, but prune_icache isn't a user-visible syncing function.
4738 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4739 * we start and wait on commits.
4740 */
4742 {
4754 /*
4755 * We need extra buffer credits since we may write into EA block
4756 * with this same handle. If journal_extend fails, then it will
4757 * only result in a minor loss of functionality for that inode.
4758 * If this is felt to be critical, then e2fsck should be run to
4759 * force a large enough s_min_extra_isize.
4760 */
4768 EXT4_STATE_NO_EXPAND);
4772 "Unable to expand inode %lu. Delete"
4775 mnt_count =
4777 }
4778 }
4779 }
4780 }
4784 }
4786 /*
4787 * ext4_dirty_inode() is called from __mark_inode_dirty()
4788 *
4789 * We're really interested in the case where a file is being extended.
4790 * i_size has been changed by generic_commit_write() and we thus need
4791 * to include the updated inode in the current transaction.
4792 *
4793 * Also, dquot_alloc_block() will always dirty the inode when blocks
4794 * are allocated to the file.
4795 *
4796 * If the inode is marked synchronous, we don't honour that here - doing
4797 * so would cause a commit on atime updates, which we don't bother doing.
4798 * We handle synchronous inodes at the highest possible level.
4799 */
4801 {
4811 out:
4813 }
4815 #if 0
4816 /*
4817 * Bind an inode's backing buffer_head into this transaction, to prevent
4818 * it from being flushed to disk early. Unlike
4819 * ext4_reserve_inode_write, this leaves behind no bh reference and
4820 * returns no iloc structure, so the caller needs to repeat the iloc
4821 * lookup to mark the inode dirty later.
4822 */
4824 {
4835 NULL,
4838 }
4839 }
4842 }
4843 #endif
4846 {
4851 /*
4852 * We have to be very careful here: changing a data block's
4853 * journaling status dynamically is dangerous. If we write a
4854 * data block to the journal, change the status and then delete
4855 * that block, we risk forgetting to revoke the old log record
4856 * from the journal and so a subsequent replay can corrupt data.
4857 * So, first we make sure that the journal is empty and that
4858 * nobody is changing anything.
4859 */
4866 /* We have to allocate physical blocks for delalloc blocks
4867 * before flushing journal. otherwise delalloc blocks can not
4868 * be allocated any more. even more truncate on delalloc blocks
4869 * could trigger BUG by flushing delalloc blocks in journal.
4870 * There is no delalloc block in non-journal data mode.
4871 */
4876 }
4878 /* Wait for all existing dio workers */
4884 /*
4885 * OK, there are no updates running now, and all cached data is
4886 * synced to disk. We are now in a completely consistent state
4887 * which doesn't have anything in the journal, and we know that
4888 * no filesystem updates are running, so it is safe to modify
4889 * the inode's in-core data-journaling state flag now.
4890 */
4897 }
4903 /* Finally we can mark the inode as dirty. */
4915 }
4918 {
4920 }
4923 {
4925 loff_t size;
4937 /* Delalloc case is easy... */
4943 ext4_da_get_block_prep);
4947 }
4951 /* Page got truncated from under us? */
4956 }
4960 else
4962 /*
4963 * Return if we have all the buffers mapped. This avoids the need to do
4964 * journal_start/journal_stop which can block and take a long time
4965 */
4969 ext4_bh_unmapped)) {
4970 /* Wait so that we don't change page under IO */
4974 }
4975 }
4977 /* OK, we need to fill the hole... */
4980 else
4982 retry_alloc:
4987 }
4996 }
4998 }
5002 out_ret:
5004 out:
5007 }