| blob | e274e9c1171f9095829aff07224dfff650a85ed2 |
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>
47 #include <trace/events/ext4.h>
49 #define MPAGE_DA_EXTENT_TAIL 0x01
53 {
55 __u16 csum_lo;
57 __u32 csum;
65 }
76 }
80 {
86 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
94 else
98 }
102 {
103 __u32 csum;
108 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
116 }
119 loff_t new_size)
120 {
122 /*
123 * If jinode is zero, then we never opened the file for
124 * writing, so there's no need to call
125 * jbd2_journal_begin_ordered_truncate() since there's no
126 * outstanding writes we need to flush.
127 */
132 new_size);
133 }
142 /*
143 * Test whether an inode is a fast symlink.
144 */
146 {
151 }
153 /*
154 * Restart the transaction associated with *handle. This does a commit,
155 * so before we call here everything must be consistently dirtied against
156 * this transaction.
157 */
160 {
163 /*
164 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
165 * moment, get_block can be called only for blocks inside i_size since
166 * page cache has been already dropped and writes are blocked by
167 * i_mutex. So we can safely drop the i_data_sem here.
168 */
177 }
179 /*
180 * Called at the last iput() if i_nlink is zero.
181 */
183 {
190 /*
191 * When journalling data dirty buffers are tracked only in the
192 * journal. So although mm thinks everything is clean and
193 * ready for reaping the inode might still have some pages to
194 * write in the running transaction or waiting to be
195 * checkpointed. Thus calling jbd2_journal_invalidatepage()
196 * (via truncate_inode_pages()) to discard these buffers can
197 * cause data loss. Also even if we did not discard these
198 * buffers, we would have no way to find them after the inode
199 * is reaped and thus user could see stale data if he tries to
200 * read them before the transaction is checkpointed. So be
201 * careful and force everything to disk here... We use
202 * ei->i_datasync_tid to store the newest transaction
203 * containing inode's data.
204 *
205 * Note that directories do not have this problem because they
206 * don't use page cache.
207 */
216 }
221 }
234 /*
235 * Protect us against freezing - iput() caller didn't have to have any
236 * protection against it
237 */
243 /*
244 * If we're going to skip the normal cleanup, we still need to
245 * make sure that the in-core orphan linked list is properly
246 * cleaned up.
247 */
251 }
261 }
265 /*
266 * ext4_ext_truncate() doesn't reserve any slop when it
267 * restarts journal transactions; therefore there may not be
268 * enough credits left in the handle to remove the inode from
269 * the orphan list and set the dtime field.
270 */
278 stop_handle:
283 }
284 }
286 /*
287 * Kill off the orphan record which ext4_truncate created.
288 * AKPM: I think this can be inside the above `if'.
289 * Note that ext4_orphan_del() has to be able to cope with the
290 * deletion of a non-existent orphan - this is because we don't
291 * know if ext4_truncate() actually created an orphan record.
292 * (Well, we could do this if we need to, but heck - it works)
293 */
297 /*
298 * One subtle ordering requirement: if anything has gone wrong
299 * (transaction abort, IO errors, whatever), then we can still
300 * do these next steps (the fs will already have been marked as
301 * having errors), but we can't free the inode if the mark_dirty
302 * fails.
303 */
305 /* If that failed, just do the required in-core inode clear. */
307 else
312 no_delete:
314 }
316 #ifdef CONFIG_QUOTA
318 {
320 }
321 #endif
323 /*
324 * Calculate the number of metadata blocks need to reserve
325 * to allocate a block located at @lblock
326 */
328 {
333 }
335 /*
336 * Called with i_data_sem down, which is important since we can call
337 * ext4_discard_preallocations() from here.
338 */
341 {
354 }
358 "with only %d reserved metadata blocks "
365 }
367 /* Update per-inode reservations */
375 /*
376 * We can release all of the reserved metadata blocks
377 * only when we have written all of the delayed
378 * allocation blocks.
379 */
384 }
387 /* Update quota subsystem for data blocks */
391 /*
392 * We did fallocate with an offset that is already delayed
393 * allocated. So on delayed allocated writeback we should
394 * not re-claim the quota for fallocated blocks.
395 */
397 }
399 /*
400 * If we have done all the pending block allocations and if
401 * there aren't any writers on the inode, we can discard the
402 * inode's preallocations.
403 */
407 }
412 {
416 "lblock %lu mapped to illegal pblock "
420 }
422 }
424 #define check_block_validity(inode, map) \
425 __check_block_validity((inode), __func__, __LINE__, (map))
427 #ifdef ES_AGGRESSIVE_TEST
433 {
437 /*
438 * There is a race window that the result is not the same.
439 * e.g. xfstests #223 when dioread_nolock enables. The reason
440 * is that we lookup a block mapping in extent status tree with
441 * out taking i_data_sem. So at the time the unwritten extent
442 * could be converted.
443 */
448 EXT4_GET_BLOCKS_KEEP_SIZE);
451 EXT4_GET_BLOCKS_KEEP_SIZE);
452 }
455 /*
456 * Clear EXT4_MAP_FROM_CLUSTER and EXT4_MAP_BOUNDARY flag
457 * because it shouldn't be marked in es_map->m_flags.
458 */
461 /*
462 * We don't check m_len because extent will be collpased in status
463 * tree. So the m_len might not equal.
464 */
469 "es_cached ex [%d/%d/%llu/%x] != "
475 }
476 }
479 /*
480 * The ext4_map_blocks() function tries to look up the requested blocks,
481 * and returns if the blocks are already mapped.
482 *
483 * Otherwise it takes the write lock of the i_data_sem and allocate blocks
484 * and store the allocated blocks in the result buffer head and mark it
485 * mapped.
486 *
487 * If file type is extents based, it will call ext4_ext_map_blocks(),
488 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
489 * based files
490 *
491 * On success, it returns the number of blocks being mapped or allocate.
492 * if create==0 and the blocks are pre-allocated and uninitialized block,
493 * the result buffer head is unmapped. If the create ==1, it will make sure
494 * the buffer head is mapped.
495 *
496 * It returns 0 if plain look up failed (blocks have not been allocated), in
497 * that case, buffer head is unmapped
498 *
499 * It returns the error in case of allocation failure.
500 */
503 {
506 #ifdef ES_AGGRESSIVE_TEST
510 #endif
517 /* Lookup extent status tree firstly */
533 }
534 #ifdef ES_AGGRESSIVE_TEST
537 #endif
539 }
541 /*
542 * Try to see if we can get the block without requesting a new
543 * file system block.
544 */
549 EXT4_GET_BLOCKS_KEEP_SIZE);
552 EXT4_GET_BLOCKS_KEEP_SIZE);
553 }
560 "ES len assertion failed for inode "
564 }
576 }
580 found:
585 }
587 /* If it is only a block(s) look up */
591 /*
592 * Returns if the blocks have already allocated
593 *
594 * Note that if blocks have been preallocated
595 * ext4_ext_get_block() returns the create = 0
596 * with buffer head unmapped.
597 */
601 /*
602 * Here we clear m_flags because after allocating an new extent,
603 * it will be set again.
604 */
607 /*
608 * New blocks allocate and/or writing to uninitialized extent
609 * will possibly result in updating i_data, so we take
610 * the write lock of i_data_sem, and call get_blocks()
611 * with create == 1 flag.
612 */
615 /*
616 * if the caller is from delayed allocation writeout path
617 * we have already reserved fs blocks for allocation
618 * let the underlying get_block() function know to
619 * avoid double accounting
620 */
623 /*
624 * We need to check for EXT4 here because migrate
625 * could have changed the inode type in between
626 */
633 /*
634 * We allocated new blocks which will result in
635 * i_data's format changing. Force the migrate
636 * to fail by clearing migrate flags
637 */
639 }
641 /*
642 * Update reserved blocks/metadata blocks after successful
643 * block allocation which had been deferred till now. We don't
644 * support fallocate for non extent files. So we can update
645 * reserve space here.
646 */
650 }
660 "ES len assertion failed for inode "
664 }
666 /*
667 * If the extent has been zeroed out, we don't need to update
668 * extent status tree.
669 */
674 }
685 }
687 has_zeroout:
693 }
695 }
697 /* Maximum number of blocks we map for direct IO at once. */
698 #define DIO_MAX_BLOCKS 4096
702 {
715 /* Direct IO write... */
720 dio_credits);
724 }
726 }
738 }
742 }
746 {
749 }
751 /*
752 * `handle' can be NULL if create is zero
753 */
756 {
768 /* ensure we send some value back into *errp */
782 }
787 /*
788 * Now that we do not always journal data, we should
789 * keep in mind whether this should always journal the
790 * new buffer as metadata. For now, regular file
791 * writes use ext4_get_block instead, so it's not a
792 * problem.
793 */
800 }
808 }
813 }
815 }
819 {
834 }
843 {
859 }
863 }
865 }
867 /*
868 * To preserve ordering, it is essential that the hole instantiation and
869 * the data write be encapsulated in a single transaction. We cannot
870 * close off a transaction and start a new one between the ext4_get_block()
871 * and the commit_write(). So doing the jbd2_journal_start at the start of
872 * prepare_write() is the right place.
873 *
874 * Also, this function can nest inside ext4_writepage(). In that case, we
875 * *know* that ext4_writepage() has generated enough buffer credits to do the
876 * whole page. So we won't block on the journal in that case, which is good,
877 * because the caller may be PF_MEMALLOC.
878 *
879 * By accident, ext4 can be reentered when a transaction is open via
880 * quota file writes. If we were to commit the transaction while thus
881 * reentered, there can be a deadlock - we would be holding a quota
882 * lock, and the commit would never complete if another thread had a
883 * transaction open and was blocking on the quota lock - a ranking
884 * violation.
885 *
886 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
887 * will _not_ run commit under these circumstances because handle->h_ref
888 * is elevated. We'll still have enough credits for the tiny quotafile
889 * write.
890 */
893 {
899 /*
900 * __block_write_begin() could have dirtied some buffers. Clean
901 * the dirty bit as jbd2_journal_get_write_access() could complain
902 * otherwise about fs integrity issues. Setting of the dirty bit
903 * by __block_write_begin() isn't a real problem here as we clear
904 * the bit before releasing a page lock and thus writeback cannot
905 * ever write the buffer.
906 */
913 }
920 {
926 pgoff_t index;
930 /*
931 * Reserve one block more for addition to orphan list in case
932 * we allocate blocks but write fails for some reason
933 */
946 }
948 /*
949 * grab_cache_page_write_begin() can take a long time if the
950 * system is thrashing due to memory pressure, or if the page
951 * is being written back. So grab it first before we start
952 * the transaction handle. This also allows us to allocate
953 * the page (if needed) without using GFP_NOFS.
954 */
955 retry_grab:
961 retry_journal:
966 }
970 /* The page got truncated from under us */
975 }
976 /* In case writeback began while the page was unlocked */
981 else
987 do_journal_get_write_access);
988 }
992 /*
993 * __block_write_begin may have instantiated a few blocks
994 * outside i_size. Trim these off again. Don't need
995 * i_size_read because we hold i_mutex.
996 *
997 * Add inode to orphan list in case we crash before
998 * truncate finishes
999 */
1006 /*
1007 * If truncate failed early the inode might
1008 * still be on the orphan list; we need to
1009 * make sure the inode is removed from the
1010 * orphan list in that case.
1011 */
1014 }
1021 }
1024 }
1026 /* For write_end() in data=journal mode */
1028 {
1037 }
1039 /*
1040 * We need to pick up the new inode size which generic_commit_write gave us
1041 * `file' can be NULL - eg, when called from page_symlink().
1042 *
1043 * ext4 never places buffers on inode->i_mapping->private_list. metadata
1044 * buffers are managed internally.
1045 */
1050 {
1063 }
1064 }
1076 /*
1077 * No need to use i_size_read() here, the i_size
1078 * cannot change under us because we hole i_mutex.
1079 *
1080 * But it's important to update i_size while still holding page lock:
1081 * page writeout could otherwise come in and zero beyond i_size.
1082 */
1086 }
1089 /* We need to mark inode dirty even if
1090 * new_i_size is less that inode->i_size
1091 * but greater than i_disksize. (hint delalloc)
1092 */
1095 }
1099 /*
1100 * Don't mark the inode dirty under page lock. First, it unnecessarily
1101 * makes the holding time of page lock longer. Second, it forces lock
1102 * ordering of page lock and transaction start for journaling
1103 * filesystems.
1104 */
1109 /* if we have allocated more blocks and copied
1110 * less. We will have blocks allocated outside
1111 * inode->i_size. So truncate them
1112 */
1114 errout:
1121 /*
1122 * If truncate failed early the inode might still be
1123 * on the orphan list; we need to make sure the inode
1124 * is removed from the orphan list in that case.
1125 */
1128 }
1131 }
1137 {
1143 loff_t new_i_size;
1159 }
1165 }
1176 }
1181 /* if we have allocated more blocks and copied
1182 * less. We will have blocks allocated outside
1183 * inode->i_size. So truncate them
1184 */
1192 /*
1193 * If truncate failed early the inode might still be
1194 * on the orphan list; we need to make sure the inode
1195 * is removed from the orphan list in that case.
1196 */
1199 }
1202 }
1204 /*
1205 * Reserve a metadata for a single block located at lblock
1206 */
1208 {
1213 ext4_lblk_t save_last_lblock;
1216 /*
1217 * recalculate the amount of metadata blocks to reserve
1218 * in order to allocate nrblocks
1219 * worse case is one extent per block
1220 */
1221 repeat:
1223 /*
1224 * ext4_calc_metadata_amount() has side effects, which we have
1225 * to be prepared undo if we fail to claim space.
1226 */
1233 /*
1234 * We do still charge estimated metadata to the sb though;
1235 * we cannot afford to run out of free blocks.
1236 */
1244 }
1246 }
1251 }
1253 /*
1254 * Reserve a single cluster located at lblock
1255 */
1257 {
1263 ext4_lblk_t save_last_lblock;
1266 /*
1267 * We will charge metadata quota at writeout time; this saves
1268 * us from metadata over-estimation, though we may go over by
1269 * a small amount in the end. Here we just reserve for data.
1270 */
1275 /*
1276 * recalculate the amount of metadata blocks to reserve
1277 * in order to allocate nrblocks
1278 * worse case is one extent per block
1279 */
1280 repeat:
1282 /*
1283 * ext4_calc_metadata_amount() has side effects, which we have
1284 * to be prepared undo if we fail to claim space.
1285 */
1292 /*
1293 * We do still charge estimated metadata to the sb though;
1294 * we cannot afford to run out of free blocks.
1295 */
1303 }
1306 }
1312 }
1315 {
1326 /*
1327 * if there aren't enough reserved blocks, then the
1328 * counter is messed up somewhere. Since this
1329 * function is called from invalidate page, it's
1330 * harmless to return without any action.
1331 */
1333 "ino %lu, to_free %d with only %d reserved "
1338 }
1342 /*
1343 * We can release all of the reserved metadata blocks
1344 * only when we have written all of the delayed
1345 * allocation blocks.
1346 * Note that in case of bigalloc, i_reserved_meta_blocks,
1347 * i_reserved_data_blocks, etc. refer to number of clusters.
1348 */
1353 }
1355 /* update fs dirty data blocks counter */
1361 }
1366 {
1374 ext4_fsblk_t lblk;
1387 to_release++;
1389 }
1396 }
1398 /* If we have released all the blocks belonging to a cluster, then we
1399 * need to release the reserved space for that cluster. */
1408 num_clusters--;
1409 }
1410 }
1412 /*
1413 * Delayed allocation stuff
1414 */
1423 /*
1424 * Extent to map - this can be after first_page because that can be
1425 * fully mapped. We somewhat abuse m_flags to store whether the extent
1426 * is delalloc or unwritten.
1427 */
1430 };
1434 {
1441 /* This is necessary when next_page == 0. */
1452 }
1468 }
1470 }
1473 }
1474 }
1477 {
1500 }
1503 {
1505 }
1507 /*
1508 * This function is grabs code from the very beginning of
1509 * ext4_map_blocks, but assumes that the caller is from delayed write
1510 * time. This function looks up the requested blocks and sets the
1511 * buffer delay bit under the protection of i_data_sem.
1512 */
1516 {
1520 #ifdef ES_AGGRESSIVE_TEST
1524 #endif
1534 /* Lookup extent status tree firstly */
1541 }
1543 /*
1544 * Delayed extent could be allocated by fallocate.
1545 * So we need to check it.
1546 */
1552 }
1563 else
1566 #ifdef ES_AGGRESSIVE_TEST
1568 #endif
1570 }
1572 /*
1573 * Try to see if we can get the block without requesting a new
1574 * file system block.
1575 */
1578 /*
1579 * We will soon create blocks for this page, and let
1580 * us pretend as if the blocks aren't allocated yet.
1581 * In case of clusters, we have to handle the work
1582 * of mapping from cluster so that the reserved space
1583 * is calculated properly.
1584 */
1591 EXT4_GET_BLOCKS_NO_PUT_HOLE);
1592 else
1594 EXT4_GET_BLOCKS_NO_PUT_HOLE);
1596 add_delayed:
1599 /*
1600 * XXX: __block_prepare_write() unmaps passed block,
1601 * is it OK?
1602 */
1603 /*
1604 * If the block was allocated from previously allocated cluster,
1605 * then we don't need to reserve it again. However we still need
1606 * to reserve metadata for every block we're going to write.
1607 */
1611 /* not enough space to reserve */
1614 }
1618 /* not enough space to reserve */
1621 }
1622 }
1629 }
1631 /* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
1632 * and it should not appear on the bh->b_state.
1633 */
1645 "ES len assertion failed for inode "
1649 }
1657 }
1659 out_unlock:
1663 }
1665 /*
1666 * This is a special get_blocks_t callback which is used by
1667 * ext4_da_write_begin(). It will either return mapped block or
1668 * reserve space for a single block.
1669 *
1670 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
1671 * We also have b_blocknr = -1 and b_bdev initialized properly
1672 *
1673 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
1674 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
1675 * initialized properly.
1676 */
1679 {
1689 /*
1690 * first, we need to know whether the block is allocated already
1691 * preallocated blocks are unmapped but should treated
1692 * the same as allocated blocks.
1693 */
1702 /* A delayed write to unwritten bh should be marked
1703 * new and mapped. Mapped ensures that we don't do
1704 * get_block multiple times when we write to the same
1705 * offset and new ensures that we do proper zero out
1706 * for partial write.
1707 */
1710 }
1712 }
1715 {
1718 }
1721 {
1724 }
1728 {
1750 }
1753 }
1754 /* As soon as we unlock the page, it can go away, but we have
1755 * references to buffers so we are safe */
1763 }
1774 do_journal_get_write_access);
1777 write_end_fn);
1778 }
1790 out:
1793 }
1795 /*
1796 * Note that we don't need to start a transaction unless we're journaling data
1797 * because we should have holes filled from ext4_page_mkwrite(). We even don't
1798 * need to file the inode to the transaction's list in ordered mode because if
1799 * we are writing back data added by write(), the inode is already there and if
1800 * we are writing back data modified via mmap(), no one guarantees in which
1801 * transaction the data will hit the disk. In case we are journaling data, we
1802 * cannot start transaction directly because transaction start ranks above page
1803 * lock so we have to do some magic.
1804 *
1805 * This function can get called via...
1806 * - ext4_writepages after taking page lock (have journal handle)
1807 * - journal_submit_inode_data_buffers (no journal handle)
1808 * - shrink_page_list via the kswapd/direct reclaim (no journal handle)
1809 * - grab_page_cache when doing write_begin (have journal handle)
1810 *
1811 * We don't do any block allocation in this function. If we have page with
1812 * multiple blocks we need to write those buffer_heads that are mapped. This
1813 * is important for mmaped based write. So if we do with blocksize 1K
1814 * truncate(f, 1024);
1815 * a = mmap(f, 0, 4096);
1816 * a[0] = 'a';
1817 * truncate(f, 4096);
1818 * we have in the page first buffer_head mapped via page_mkwrite call back
1819 * but other buffer_heads would be unmapped but dirty (dirty done via the
1820 * do_wp_page). So writepage should write the first block. If we modify
1821 * the mmap area beyond 1024 we will again get a page_fault and the
1822 * page_mkwrite callback will do the block allocation and mark the
1823 * buffer_heads mapped.
1824 *
1825 * We redirty the page if we have any buffer_heads that is either delay or
1826 * unwritten in the page.
1827 *
1828 * We can get recursively called as show below.
1829 *
1830 * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1831 * ext4_writepage()
1832 *
1833 * But since we don't do any block allocation we should not deadlock.
1834 * Page also have the dirty flag cleared so we don't get recurive page_lock.
1835 */
1838 {
1840 loff_t size;
1850 else
1854 /*
1855 * We cannot do block allocation or other extent handling in this
1856 * function. If there are buffers needing that, we have to redirty
1857 * the page. But we may reach here when we do a journal commit via
1858 * journal_submit_inode_data_buffers() and in that case we must write
1859 * allocated buffers to achieve data=ordered mode guarantees.
1860 */
1862 ext4_bh_delay_or_unwritten)) {
1865 /*
1866 * For memory cleaning there's no point in writing only
1867 * some buffers. So just bail out. Warn if we came here
1868 * from direct reclaim.
1869 */
1874 }
1875 }
1878 /*
1879 * It's mmapped pagecache. Add buffers and journal it. There
1880 * doesn't seem much point in redirtying the page here.
1881 */
1890 }
1893 /* Drop io_end reference we got from init */
1896 }
1899 {
1907 else
1916 }
1918 #define BH_FLAGS ((1 << BH_Unwritten) | (1 << BH_Delay))
1920 /*
1921 * mballoc gives us at most this number of blocks...
1922 * XXX: That seems to be only a limitation of ext4_mb_normalize_request().
1923 * The rest of mballoc seems to handle chunks up to full group size.
1924 */
1925 #define MAX_WRITEPAGES_EXTENT_LEN 2048
1927 /*
1928 * mpage_add_bh_to_extent - try to add bh to extent of blocks to map
1929 *
1930 * @mpd - extent of blocks
1931 * @lblk - logical number of the block in the file
1932 * @bh - buffer head we want to add to the extent
1933 *
1934 * The function is used to collect contig. blocks in the same state. If the
1935 * buffer doesn't require mapping for writeback and we haven't started the
1936 * extent of buffers to map yet, the function returns 'true' immediately - the
1937 * caller can write the buffer right away. Otherwise the function returns true
1938 * if the block has been added to the extent, false if the block couldn't be
1939 * added.
1940 */
1943 {
1946 /* Buffer that doesn't need mapping for writeback? */
1949 /* So far no extent to map => we write the buffer right away */
1953 }
1955 /* First block in the extent? */
1961 }
1963 /* Don't go larger than mballoc is willing to allocate */
1967 /* Can we merge the block to our big extent? */
1972 }
1974 }
1976 /*
1977 * mpage_process_page_bufs - submit page buffers for IO or add them to extent
1978 *
1979 * @mpd - extent of blocks for mapping
1980 * @head - the first buffer in the page
1981 * @bh - buffer we should start processing from
1982 * @lblk - logical number of the block in the file corresponding to @bh
1983 *
1984 * Walk through page buffers from @bh upto @head (exclusive) and either submit
1985 * the page for IO if all buffers in this page were mapped and there's no
1986 * accumulated extent of buffers to map or add buffers in the page to the
1987 * extent of buffers to map. The function returns 1 if the caller can continue
1988 * by processing the next page, 0 if it should stop adding buffers to the
1989 * extent to map because we cannot extend it anymore. It can also return value
1990 * < 0 in case of error during IO submission.
1991 */
1995 ext4_lblk_t lblk)
1996 {
2006 /* Found extent to map? */
2009 /* Everything mapped so far and we hit EOF */
2011 }
2013 /* So far everything mapped? Submit the page for IO. */
2018 }
2020 }
2022 /*
2023 * mpage_map_buffers - update buffers corresponding to changed extent and
2024 * submit fully mapped pages for IO
2025 *
2026 * @mpd - description of extent to map, on return next extent to map
2027 *
2028 * Scan buffers corresponding to changed extent (we expect corresponding pages
2029 * to be already locked) and update buffer state according to new extent state.
2030 * We map delalloc buffers to their physical location, clear unwritten bits,
2031 * and mark buffers as uninit when we perform writes to uninitialized extents
2032 * and do extent conversion after IO is finished. If the last page is not fully
2033 * mapped, we update @map to the next extent in the last page that needs
2034 * mapping. Otherwise we submit the page for IO.
2035 */
2037 {
2044 ext4_lblk_t lblk;
2045 sector_t pblock;
2056 PAGEVEC_SIZE);
2064 /* Up to 'end' pages must be contiguous */
2071 /*
2072 * Buffer after end of mapped extent.
2073 * Find next buffer in the page to map.
2074 */
2077 /*
2078 * FIXME: If dioread_nolock supports
2079 * blocksize < pagesize, we need to make
2080 * sure we add size mapped so far to
2081 * io_end->size as the following call
2082 * can submit the page for IO.
2083 */
2090 }
2094 }
2098 /*
2099 * FIXME: This is going to break if dioread_nolock
2100 * supports blocksize < pagesize as we will try to
2101 * convert potentially unmapped parts of inode.
2102 */
2104 /* Page fully mapped - let IO run! */
2109 }
2110 start++;
2111 }
2113 }
2114 /* Extent fully mapped and matches with page boundary. We are done. */
2118 }
2121 {
2128 /*
2129 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
2130 * to convert an uninitialized extent to be initialized (in the case
2131 * where we have written into one or more preallocated blocks). It is
2132 * possible that we're going to need more metadata blocks than
2133 * previously reserved. However we must not fail because we're in
2134 * writeback and there is nothing we can do about it so it might result
2135 * in data loss. So use reserved blocks to allocate metadata if
2136 * possible.
2137 *
2138 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE if the blocks
2139 * in question are delalloc blocks. This affects functions in many
2140 * different parts of the allocation call path. This flag exists
2141 * primarily because we don't want to change *many* call functions, so
2142 * ext4_map_blocks() will set the EXT4_STATE_DELALLOC_RESERVED flag
2143 * once the inode's allocation semaphore is taken.
2144 */
2146 EXT4_GET_BLOCKS_METADATA_NOFAIL;
2160 }
2162 }
2171 }
2173 }
2175 /*
2176 * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length
2177 * mpd->len and submit pages underlying it for IO
2178 *
2179 * @handle - handle for journal operations
2180 * @mpd - extent to map
2181 *
2182 * The function maps extent starting at mpd->lblk of length mpd->len. If it is
2183 * delayed, blocks are allocated, if it is unwritten, we may need to convert
2184 * them to initialized or split the described range from larger unwritten
2185 * extent. Note that we need not map all the described range since allocation
2186 * can return less blocks or the range is covered by more unwritten extents. We
2187 * cannot map more because we are limited by reserved transaction credits. On
2188 * the other hand we always make sure that the last touched page is fully
2189 * mapped so that it can be written out (and thus forward progress is
2190 * guaranteed). After mapping we submit all mapped pages for IO.
2191 */
2195 {
2199 loff_t disksize;
2210 /*
2211 * Let the uper layers retry transient errors.
2212 * In the case of ENOSPC, if ext4_count_free_blocks()
2213 * is non-zero, a commit should free up blocks.
2214 */
2219 "Delayed block allocation failed for "
2220 "inode %lu at logical offset %llu with"
2226 "This should not happen!! Data will "
2230 invalidate_dirty_pages:
2233 }
2234 /*
2235 * Update buffer state, submit mapped pages, and get us new
2236 * extent to map
2237 */
2243 /* Update on-disk size after IO is submitted */
2256 }
2258 }
2260 /*
2261 * Calculate the total number of credits to reserve for one writepages
2262 * iteration. This is called from ext4_writepages(). We map an extent of
2263 * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
2264 * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN +
2265 * bpp - 1 blocks in bpp different extents.
2266 */
2268 {
2273 }
2275 /*
2276 * mpage_prepare_extent_to_map - find & lock contiguous range of dirty pages
2277 * and underlying extent to map
2278 *
2279 * @mpd - where to look for pages
2280 *
2281 * Walk dirty pages in the mapping. If they are fully mapped, submit them for
2282 * IO immediately. When we find a page which isn't mapped we start accumulating
2283 * extent of buffers underlying these pages that needs mapping (formed by
2284 * either delayed or unwritten buffers). We also lock the pages containing
2285 * these buffers. The extent found is returned in @mpd structure (starting at
2286 * mpd->lblk with length mpd->len blocks).
2287 *
2288 * Note that this function can attach bios to one io_end structure which are
2289 * neither logically nor physically contiguous. Although it may seem as an
2290 * unnecessary complication, it is actually inevitable in blocksize < pagesize
2291 * case as we need to track IO to all buffers underlying a page in one io_end.
2292 */
2294 {
2303 ext4_lblk_t lblk;
2308 else
2323 /*
2324 * At this point, the page may be truncated or
2325 * invalidated (changing page->mapping to NULL), or
2326 * even swizzled back from swapper_space to tmpfs file
2327 * mapping. However, page->index will not change
2328 * because we have a reference on the page.
2329 */
2333 /* If we can't merge this page, we are done. */
2338 /*
2339 * If the page is no longer dirty, or its mapping no
2340 * longer corresponds to inode we are writing (which
2341 * means it has been truncated or invalidated), or the
2342 * page is already under writeback and we are not doing
2343 * a data integrity writeback, skip the page
2344 */
2351 }
2359 /* Add all dirty buffers to mpd */
2368 /*
2369 * Accumulated enough dirty pages? This doesn't apply
2370 * to WB_SYNC_ALL mode. For integrity sync we have to
2371 * keep going because someone may be concurrently
2372 * dirtying pages, and we might have synced a lot of
2373 * newly appeared dirty pages, but have not synced all
2374 * of the old dirty pages.
2375 */
2380 }
2383 }
2385 out:
2388 }
2392 {
2397 }
2401 {
2417 /*
2418 * No pages to write? This is mainly a kludge to avoid starting
2419 * a transaction for special inodes like journal inode on last iput()
2420 * because that could violate lock ordering on umount
2421 */
2433 }
2435 /*
2436 * If the filesystem has aborted, it is read-only, so return
2437 * right away instead of dumping stack traces later on that
2438 * will obscure the real source of the problem. We test
2439 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2440 * the latter could be true if the filesystem is mounted
2441 * read-only, and in that case, ext4_writepages should
2442 * *never* be called, so if that ever happens, we would want
2443 * the stack trace.
2444 */
2449 /*
2450 * We may need to convert up to one extent per block in
2451 * the page and we may dirty the inode.
2452 */
2454 }
2456 /*
2457 * If we have inline data and arrive here, it means that
2458 * we will soon create the block for the 1st page, so
2459 * we'd better clear the inline data here.
2460 */
2462 /* Just inode will be modified... */
2467 }
2469 EXT4_STATE_MAY_INLINE_DATA));
2472 }
2486 }
2491 retry:
2497 /* For each extent of pages we use new io_end */
2502 }
2504 /*
2505 * We have two constraints: We find one extent to map and we
2506 * must always write out whole page (makes a difference when
2507 * blocksize < pagesize) so that we don't block on IO when we
2508 * try to write out the rest of the page. Journalled mode is
2509 * not supported by delalloc.
2510 */
2514 /* start a new transaction */
2522 /* Release allocated io_end */
2525 }
2534 /*
2535 * We scanned the whole range (or exhausted
2536 * nr_to_write), submitted what was mapped and
2537 * didn't find anything needing mapping. We are
2538 * done.
2539 */
2541 }
2542 }
2544 /* Submit prepared bio */
2546 /* Unlock pages we didn't use */
2548 /* Drop our io_end reference we got from init */
2552 /*
2553 * Commit the transaction which would
2554 * free blocks released in the transaction
2555 * and try again
2556 */
2560 }
2561 /* Fatal error - ENOMEM, EIO... */
2564 }
2571 }
2573 /* Update index */
2575 /*
2576 * Set the writeback_index so that range_cyclic
2577 * mode will write it back later
2578 */
2581 out_writepages:
2585 }
2588 {
2592 /*
2593 * switch to non delalloc mode if we are running low
2594 * on free block. The free block accounting via percpu
2595 * counters can get slightly wrong with percpu_counter_batch getting
2596 * accumulated on each CPU without updating global counters
2597 * Delalloc need an accurate free block accounting. So switch
2598 * to non delalloc when we are near to error range.
2599 */
2600 free_clusters =
2602 dirty_clusters =
2604 /*
2605 * Start pushing delalloc when 1/2 of free blocks are dirty.
2606 */
2612 /*
2613 * free block count is less than 150% of dirty blocks
2614 * or free blocks is less than watermark
2615 */
2617 }
2619 }
2624 {
2627 pgoff_t index;
2637 }
2649 }
2651 /*
2652 * grab_cache_page_write_begin() can take a long time if the
2653 * system is thrashing due to memory pressure, or if the page
2654 * is being written back. So grab it first before we start
2655 * the transaction handle. This also allows us to allocate
2656 * the page (if needed) without using GFP_NOFS.
2657 */
2658 retry_grab:
2664 /*
2665 * With delayed allocation, we don't log the i_disksize update
2666 * if there is delayed block allocation. But we still need
2667 * to journalling the i_disksize update if writes to the end
2668 * of file which has an already mapped buffer.
2669 */
2670 retry_journal:
2675 }
2679 /* The page got truncated from under us */
2684 }
2685 /* In case writeback began while the page was unlocked */
2692 /*
2693 * block_write_begin may have instantiated a few blocks
2694 * outside i_size. Trim these off again. Don't need
2695 * i_size_read because we hold i_mutex.
2696 */
2706 }
2710 }
2712 /*
2713 * Check if we should update i_disksize
2714 * when write to the end of file but not require block allocation
2715 */
2718 {
2733 }
2739 {
2743 loff_t new_i_size;
2755 /*
2756 * generic_write_end() will run mark_inode_dirty() if i_size
2757 * changes. So let's piggyback the i_disksize mark_inode_dirty
2758 * into that.
2759 */
2768 /* We need to mark inode dirty even if
2769 * new_i_size is less that inode->i_size
2770 * bu greater than i_disksize.(hint delalloc)
2771 */
2773 }
2774 }
2780 page);
2781 else
2793 }
2797 {
2798 /*
2799 * Drop reserved blocks
2800 */
2807 out:
2811 }
2813 /*
2814 * Force all delayed allocation blocks to be allocated for a given inode.
2815 */
2817 {
2824 /*
2825 * We do something simple for now. The filemap_flush() will
2826 * also start triggering a write of the data blocks, which is
2827 * not strictly speaking necessary (and for users of
2828 * laptop_mode, not even desirable). However, to do otherwise
2829 * would require replicating code paths in:
2830 *
2831 * ext4_writepages() ->
2832 * write_cache_pages() ---> (via passed in callback function)
2833 * __mpage_da_writepage() -->
2834 * mpage_add_bh_to_extent()
2835 * mpage_da_map_blocks()
2836 *
2837 * The problem is that write_cache_pages(), located in
2838 * mm/page-writeback.c, marks pages clean in preparation for
2839 * doing I/O, which is not desirable if we're not planning on
2840 * doing I/O at all.
2841 *
2842 * We could call write_cache_pages(), and then redirty all of
2843 * the pages by calling redirty_page_for_writepage() but that
2844 * would be ugly in the extreme. So instead we would need to
2845 * replicate parts of the code in the above functions,
2846 * simplifying them because we wouldn't actually intend to
2847 * write out the pages, but rather only collect contiguous
2848 * logical block extents, call the multi-block allocator, and
2849 * then update the buffer heads with the block allocations.
2850 *
2851 * For now, though, we'll cheat by calling filemap_flush(),
2852 * which will map the blocks, and start the I/O, but not
2853 * actually wait for the I/O to complete.
2854 */
2856 }
2858 /*
2859 * bmap() is special. It gets used by applications such as lilo and by
2860 * the swapper to find the on-disk block of a specific piece of data.
2861 *
2862 * Naturally, this is dangerous if the block concerned is still in the
2863 * journal. If somebody makes a swapfile on an ext4 data-journaling
2864 * filesystem and enables swap, then they may get a nasty shock when the
2865 * data getting swapped to that swapfile suddenly gets overwritten by
2866 * the original zero's written out previously to the journal and
2867 * awaiting writeback in the kernel's buffer cache.
2868 *
2869 * So, if we see any bmap calls here on a modified, data-journaled file,
2870 * take extra steps to flush any blocks which might be in the cache.
2871 */
2873 {
2878 /*
2879 * We can get here for an inline file via the FIBMAP ioctl
2880 */
2886 /*
2887 * With delalloc we want to sync the file
2888 * so that we can make sure we allocate
2889 * blocks for file
2890 */
2892 }
2896 /*
2897 * This is a REALLY heavyweight approach, but the use of
2898 * bmap on dirty files is expected to be extremely rare:
2899 * only if we run lilo or swapon on a freshly made file
2900 * do we expect this to happen.
2901 *
2902 * (bmap requires CAP_SYS_RAWIO so this does not
2903 * represent an unprivileged user DOS attack --- we'd be
2904 * in trouble if mortal users could trigger this path at
2905 * will.)
2906 *
2907 * NB. EXT4_STATE_JDATA is not set on files other than
2908 * regular files. If somebody wants to bmap a directory
2909 * or symlink and gets confused because the buffer
2910 * hasn't yet been flushed to disk, they deserve
2911 * everything they get.
2912 */
2922 }
2925 }
2928 {
2941 }
2943 static int
2946 {
2949 /* If the file has inline data, no need to do readpages. */
2954 }
2958 {
2961 /* No journalling happens on data buffers when this function is used */
2965 }
2970 {
2975 /*
2976 * If it's a full truncate we just forget about the pending dirtying
2977 */
2982 }
2984 /* Wrapper for aops... */
2988 {
2990 }
2993 {
2998 /* Page has dirty journalled data -> cannot release */
3003 else
3005 }
3007 /*
3008 * ext4_get_block used when preparing for a DIO write or buffer write.
3009 * We allocate an uinitialized extent if blocks haven't been allocated.
3010 * The extent will be converted to initialized after the IO is complete.
3011 */
3014 {
3018 EXT4_GET_BLOCKS_IO_CREATE_EXT);
3019 }
3023 {
3027 EXT4_GET_BLOCKS_NO_LOCK);
3028 }
3032 {
3035 /* if not async direct IO just return */
3042 size);
3048 }
3050 /*
3051 * For ext4 extent files, ext4 will do direct-io write to holes,
3052 * preallocated extents, and those write extend the file, no need to
3053 * fall back to buffered IO.
3054 *
3055 * For holes, we fallocate those blocks, mark them as uninitialized
3056 * If those blocks were preallocated, we mark sure they are split, but
3057 * still keep the range to write as uninitialized.
3058 *
3059 * The unwritten extents will be converted to written when DIO is completed.
3060 * For async direct IO, since the IO may still pending when return, we
3061 * set up an end_io call back function, which will do the conversion
3062 * when async direct IO completed.
3063 *
3064 * If the O_DIRECT write will extend the file then add this inode to the
3065 * orphan list. So recovery will truncate it back to the original size
3066 * if the machine crashes during the write.
3067 *
3068 */
3072 {
3075 ssize_t ret;
3083 /* Use the old path for reads and writes beyond i_size. */
3089 /*
3090 * Make all waiters for direct IO properly wait also for extent
3091 * conversion. This also disallows race between truncate() and
3092 * overwrite DIO as i_dio_count needs to be incremented under i_mutex.
3093 */
3097 /* If we do a overwrite dio, i_mutex locking can be released */
3103 }
3105 /*
3106 * We could direct write to holes and fallocate.
3107 *
3108 * Allocated blocks to fill the hole are marked as
3109 * uninitialized to prevent parallel buffered read to expose
3110 * the stale data before DIO complete the data IO.
3111 *
3112 * As to previously fallocated extents, ext4 get_block will
3113 * just simply mark the buffer mapped but still keep the
3114 * extents uninitialized.
3115 *
3116 * For non AIO case, we will convert those unwritten extents
3117 * to written after return back from blockdev_direct_IO.
3118 *
3119 * For async DIO, the conversion needs to be deferred when the
3120 * IO is completed. The ext4 end_io callback function will be
3121 * called to take care of the conversion work. Here for async
3122 * case, we allocate an io_end structure to hook to the iocb.
3123 */
3131 }
3132 /*
3133 * Grab reference for DIO. Will be dropped in ext4_end_io_dio()
3134 */
3136 /*
3137 * we save the io structure for current async direct
3138 * IO, so that later ext4_map_blocks() could flag the
3139 * io structure whether there is a unwritten extents
3140 * needs to be converted when IO is completed.
3141 */
3143 }
3150 }
3154 get_block_func,
3155 ext4_end_io_dio,
3156 NULL,
3157 dio_flags);
3159 /*
3160 * Put our reference to io_end. This can free the io_end structure e.g.
3161 * in sync IO case or in case of error. It can even perform extent
3162 * conversion if all bios we submitted finished before we got here.
3163 * Note that in that case iocb->private can be already set to NULL
3164 * here.
3165 */
3169 /*
3170 * When no IO was submitted ext4_end_io_dio() was not
3171 * called so we have to put iocb's reference.
3172 */
3178 }
3179 }
3181 EXT4_STATE_DIO_UNWRITTEN)) {
3183 /*
3184 * for non AIO case, since the IO is already
3185 * completed, we could do the conversion right here
3186 */
3192 }
3194 retake_lock:
3197 /* take i_mutex locking again if we do a ovewrite dio */
3201 }
3204 }
3209 {
3212 ssize_t ret;
3214 /*
3215 * If we are doing data journalling we don't support O_DIRECT
3216 */
3220 /* Let buffer I/O handle the inline data case. */
3227 else
3232 }
3234 /*
3235 * Pages can be marked dirty completely asynchronously from ext4's journalling
3236 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
3237 * much here because ->set_page_dirty is called under VFS locks. The page is
3238 * not necessarily locked.
3239 *
3240 * We cannot just dirty the page and leave attached buffers clean, because the
3241 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
3242 * or jbddirty because all the journalling code will explode.
3243 *
3244 * So what we do is to mark the page "pending dirty" and next time writepage
3245 * is called, propagate that into the buffers appropriately.
3246 */
3248 {
3251 }
3267 };
3283 };
3299 };
3302 {
3315 }
3318 else
3320 }
3322 /*
3323 * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
3324 * up to the end of the block which corresponds to `from'.
3325 * This required during truncate. We need to physically zero the tail end
3326 * of that block so it doesn't yield old data if the file is later grown.
3327 */
3330 {
3340 }
3342 /*
3343 * ext4_block_zero_page_range() zeros out a mapping of length 'length'
3344 * starting from file offset 'from'. The range to be zero'd must
3345 * be contained with in one block. If the specified range exceeds
3346 * the end of the block it will be shortened to end of the block
3347 * that cooresponds to 'from'
3348 */
3351 {
3355 ext4_lblk_t iblock;
3369 /*
3370 * correct length if it does not fall between
3371 * 'from' and the end of the block
3372 */
3381 /* Find the buffer that contains "offset" */
3386 iblock++;
3388 }
3392 }
3396 /* unmapped? It's a hole - nothing to do */
3400 }
3401 }
3403 /* Ok, it's mapped. Make sure it's up-to-date */
3411 /* Uhhuh. Read error. Complain and punt. */
3414 }
3420 }
3431 }
3433 unlock:
3437 }
3441 {
3455 /* Handle partial zero within the single block */
3461 }
3462 /* Handle partial zero out on the start of the range */
3468 }
3469 /* Handle partial zero out on the end of the range */
3475 }
3478 {
3486 }
3488 /*
3489 * ext4_punch_hole: punches a hole in a file by releaseing the blocks
3490 * associated with the given offset and length
3491 *
3492 * @inode: File inode
3493 * @offset: The offset where the hole will begin
3494 * @len: The length of the hole
3495 *
3496 * Returns: 0 on success or negative on failure
3497 */
3500 {
3513 /* TODO: Add support for bigalloc file systems */
3515 }
3519 /*
3520 * Write out all dirty pages to avoid race conditions
3521 * Then release them.
3522 */
3528 }
3531 /* It's not possible punch hole on append only file */
3535 }
3539 }
3541 /* No need to punch hole beyond i_size */
3545 /*
3546 * If the hole extends beyond i_size, set the hole
3547 * to end after the page that contains i_size
3548 */
3552 offset;
3553 }
3557 /*
3558 * Attach jinode to inode for jbd2 if we do any zeroing of
3559 * partial block
3560 */
3565 }
3570 /* Now release the pages and zero block aligned part of pages*/
3573 last_block_offset);
3575 /* Wait all existing dio workers, newcomers will block on i_mutex */
3581 else
3588 }
3591 length);
3599 /* If there are no blocks to remove, return now */
3611 }
3616 else
3618 stop_block);
3626 out_stop:
3628 out_dio:
3630 out_mutex:
3633 }
3636 {
3649 }
3653 }
3658 }
3660 /*
3661 * ext4_truncate()
3662 *
3663 * We block out ext4_get_block() block instantiations across the entire
3664 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3665 * simultaneously on behalf of the same inode.
3666 *
3667 * As we work through the truncate and commit bits of it to the journal there
3668 * is one core, guiding principle: the file's tree must always be consistent on
3669 * disk. We must be able to restart the truncate after a crash.
3670 *
3671 * The file's tree may be transiently inconsistent in memory (although it
3672 * probably isn't), but whenever we close off and commit a journal transaction,
3673 * the contents of (the filesystem + the journal) must be consistent and
3674 * restartable. It's pretty simple, really: bottom up, right to left (although
3675 * left-to-right works OK too).
3676 *
3677 * Note that at recovery time, journal replay occurs *before* the restart of
3678 * truncate against the orphan inode list.
3679 *
3680 * The committed inode has the new, desired i_size (which is the same as
3681 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see
3682 * that this inode's truncate did not complete and it will again call
3683 * ext4_truncate() to have another go. So there will be instantiated blocks
3684 * to the right of the truncation point in a crashed ext4 filesystem. But
3685 * that's fine - as long as they are linked from the inode, the post-crash
3686 * ext4_truncate() run will find them and release them.
3687 */
3689 {
3695 /*
3696 * There is a possibility that we're either freeing the inode
3697 * or it completely new indode. In those cases we might not
3698 * have i_mutex locked because it's not necessary.
3699 */
3718 }
3720 /* If we zero-out tail of the page, we have to create jinode for jbd2 */
3724 }
3728 else
3735 }
3740 /*
3741 * We add the inode to the orphan list, so that if this
3742 * truncate spans multiple transactions, and we crash, we will
3743 * resume the truncate when the filesystem recovers. It also
3744 * marks the inode dirty, to catch the new size.
3745 *
3746 * Implication: the file must always be in a sane, consistent
3747 * truncatable state while each transaction commits.
3748 */
3758 else
3766 out_stop:
3767 /*
3768 * If this was a simple ftruncate() and the file will remain alive,
3769 * then we need to clear up the orphan record which we created above.
3770 * However, if this was a real unlink then we were called by
3771 * ext4_delete_inode(), and we allow that function to clean up the
3772 * orphan info for us.
3773 */
3782 }
3784 /*
3785 * ext4_get_inode_loc returns with an extra refcount against the inode's
3786 * underlying buffer_head on success. If 'in_mem' is true, we have all
3787 * data in memory that is needed to recreate the on-disk version of this
3788 * inode.
3789 */
3792 {
3796 ext4_fsblk_t block;
3808 /*
3809 * Figure out the offset within the block group inode table
3810 */
3823 /*
3824 * If the buffer has the write error flag, we have failed
3825 * to write out another inode in the same block. In this
3826 * case, we don't have to read the block because we may
3827 * read the old inode data successfully.
3828 */
3833 /* someone brought it uptodate while we waited */
3836 }
3838 /*
3839 * If we have all information of the inode in memory and this
3840 * is the only valid inode in the block, we need not read the
3841 * block.
3842 */
3849 /* Is the inode bitmap in cache? */
3854 /*
3855 * If the inode bitmap isn't in cache then the
3856 * optimisation may end up performing two reads instead
3857 * of one, so skip it.
3858 */
3862 }
3868 }
3871 /* all other inodes are free, so skip I/O */
3876 }
3877 }
3879 make_io:
3880 /*
3881 * If we need to do any I/O, try to pre-readahead extra
3882 * blocks from the inode table.
3883 */
3890 /* s_inode_readahead_blks is always a power of 2 */
3903 }
3905 /*
3906 * There are other valid inodes in the buffer, this inode
3907 * has in-inode xattrs, or we don't have this inode in memory.
3908 * Read the block from disk.
3909 */
3920 }
3921 }
3922 has_buffer:
3925 }
3928 {
3929 /* We have all inode data except xattrs in memory here. */
3932 }
3935 {
3949 }
3951 /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3953 {
3962 EXT4_DIRSYNC_FL);
3974 }
3978 {
3979 blkcnt_t i_blocks ;
3984 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
3985 /* we are using combined 48 bit field */
3989 /* i_blocks represent file system block size */
3993 }
3996 }
3997 }
4002 {
4010 }
4013 {
4021 uid_t i_uid;
4022 gid_t i_gid;
4047 }
4051 /* Precompute checksum seed for inode metadata */
4053 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
4055 __u32 csum;
4062 }
4068 }
4076 }
4085 /* We now have enough fields to check if the inode was active or not.
4086 * This is needed because nfsd might try to access dead inodes
4087 * the test is that same one that e2fsck uses
4088 * NeilBrown 1999oct15
4089 */
4094 /* this inode is deleted */
4097 }
4098 /* The only unlinked inodes we let through here have
4099 * valid i_mode and are being read by the orphan
4100 * recovery code: that's fine, we're about to complete
4101 * the process of deleting those.
4102 * OR it is the EXT4_BOOT_LOADER_INO which is
4103 * not initialized on a new filesystem. */
4104 }
4113 #ifdef CONFIG_QUOTA
4115 #endif
4119 /*
4120 * NOTE! The in-memory inode i_data array is in little-endian order
4121 * even on big-endian machines: we do NOT byteswap the block numbers!
4122 */
4127 /*
4128 * Set transaction id's of transactions that have to be committed
4129 * to finish f[data]sync. We set them to currently running transaction
4130 * as we cannot be sure that the inode or some of its metadata isn't
4131 * part of the transaction - the inode could have been reclaimed and
4132 * now it is reread from disk.
4133 */
4136 tid_t tid;
4141 else
4145 else
4150 }
4154 /* The extra space is currently unused. Use it. */
4156 EXT4_GOOD_OLD_INODE_SIZE;
4159 }
4160 }
4172 }
4186 /* Validate extent which is part of inode */
4191 /* Validate block references which are part of inode */
4193 }
4194 }
4213 }
4220 else
4229 }
4235 bad_inode:
4239 }
4244 {
4250 /*
4251 * i_blocks can be represented in a 32 bit variable
4252 * as multiple of 512 bytes
4253 */
4258 }
4263 /*
4264 * i_blocks can be represented in a 48 bit variable
4265 * as multiple of 512 bytes
4266 */
4272 /* i_block is stored in file system block size */
4276 }
4278 }
4280 /*
4281 * Post the struct inode info into an on-disk inode location in the
4282 * buffer-cache. This gobbles the caller's reference to the
4283 * buffer_head in the inode location struct.
4284 *
4285 * The caller must have write access to iloc->bh.
4286 */
4290 {
4296 uid_t i_uid;
4297 gid_t i_gid;
4299 /* For fields not not tracking in the in-memory inode,
4300 * initialise them to zero for new inodes. */
4311 /*
4312 * Fix up interoperability with old kernels. Otherwise, old inodes get
4313 * re-used with the upper 16 bits of the uid/gid intact
4314 */
4323 }
4329 }
4349 }
4353 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4356 /* If this is the first large file
4357 * created, add a flag to the superblock.
4358 */
4365 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4368 }
4369 }
4381 }
4385 }
4393 }
4404 out_brelse:
4408 }
4410 /*
4411 * ext4_write_inode()
4412 *
4413 * We are called from a few places:
4414 *
4415 * - Within generic_file_write() for O_SYNC files.
4416 * Here, there will be no transaction running. We wait for any running
4417 * transaction to commit.
4418 *
4419 * - Within sys_sync(), kupdate and such.
4420 * We wait on commit, if tol to.
4421 *
4422 * - Within prune_icache() (PF_MEMALLOC == true)
4423 * Here we simply return. We can't afford to block kswapd on the
4424 * journal commit.
4425 *
4426 * In all cases it is actually safe for us to return without doing anything,
4427 * because the inode has been copied into a raw inode buffer in
4428 * ext4_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
4429 * knfsd.
4430 *
4431 * Note that we are absolutely dependent upon all inode dirtiers doing the
4432 * right thing: they *must* call mark_inode_dirty() after dirtying info in
4433 * which we are interested.
4434 *
4435 * It would be a bug for them to not do this. The code:
4436 *
4437 * mark_inode_dirty(inode)
4438 * stuff();
4439 * inode->i_size = expr;
4440 *
4441 * is in error because a kswapd-driven write_inode() could occur while
4442 * `stuff()' is running, and the new i_size will be lost. Plus the inode
4443 * will no longer be on the superblock's dirty inode list.
4444 */
4446 {
4457 }
4475 }
4477 }
4479 }
4481 /*
4482 * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
4483 * buffers that are attached to a page stradding i_size and are undergoing
4484 * commit. In that case we have to wait for commit to finish and try again.
4485 */
4487 {
4495 /*
4496 * All buffers in the last page remain valid? Then there's nothing to
4497 * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
4498 * blocksize case
4499 */
4520 }
4521 }
4523 /*
4524 * ext4_setattr()
4525 *
4526 * Called from notify_change.
4527 *
4528 * We want to trap VFS attempts to truncate the file as soon as
4529 * possible. In particular, we want to make sure that when the VFS
4530 * shrinks i_size, we put the inode on the orphan list and modify
4531 * i_disksize immediately, so that during the subsequent flushing of
4532 * dirty pages and freeing of disk blocks, we can guarantee that any
4533 * commit will leave the blocks being flushed in an unused state on
4534 * disk. (On recovery, the inode will get truncated and the blocks will
4535 * be freed, so we have a strong guarantee that no future commit will
4536 * leave these blocks visible to the user.)
4537 *
4538 * Another thing we have to assure is that if we are in ordered mode
4539 * and inode is still attached to the committing transaction, we must
4540 * we start writeout of all the dirty pages which are being truncated.
4541 * This way we are sure that all the data written in the previous
4542 * transaction are already on disk (truncate waits for pages under
4543 * writeback).
4544 *
4545 * Called with inode->i_mutex down.
4546 */
4548 {
4564 /* (user+group)*(old+new) structure, inode write (sb,
4565 * inode block, ? - but truncate inode update has it) */
4572 }
4577 }
4578 /* Update corresponding info in inode so that everything is in
4579 * one transaction */
4586 }
4596 }
4604 }
4609 }
4613 }
4619 /*
4620 * We have to update i_size under i_data_sem together
4621 * with i_disksize to avoid races with writeback code
4622 * running ext4_wb_update_i_disksize().
4623 */
4631 }
4635 /*
4636 * Blocks are going to be removed from the inode. Wait
4637 * for dio in flight. Temporarily disable
4638 * dioread_nolock to prevent livelock.
4639 */
4647 }
4648 /*
4649 * Truncate pagecache after we've waited for commit
4650 * in data=journal mode to make pages freeable.
4651 */
4653 }
4654 /*
4655 * We want to call ext4_truncate() even if attr->ia_size ==
4656 * inode->i_size for cases like truncation of fallocated space
4657 */
4664 }
4666 /*
4667 * If the call to ext4_truncate failed to get a transaction handle at
4668 * all, we need to clean up the in-core orphan list manually.
4669 */
4676 err_out:
4681 }
4685 {
4692 /*
4693 * We can't update i_blocks if the block allocation is delayed
4694 * otherwise in the case of system crash before the real block
4695 * allocation is done, we will have i_blocks inconsistent with
4696 * on-disk file blocks.
4697 * We always keep i_blocks updated together with real
4698 * allocation. But to not confuse with user, stat
4699 * will return the blocks that include the delayed allocation
4700 * blocks for this file.
4701 */
4707 }
4711 {
4715 }
4717 /*
4718 * Account for index blocks, block groups bitmaps and block group
4719 * descriptor blocks if modify datablocks and index blocks
4720 * worse case, the indexs blocks spread over different block groups
4721 *
4722 * If datablocks are discontiguous, they are possible to spread over
4723 * different block groups too. If they are contiguous, with flexbg,
4724 * they could still across block group boundary.
4725 *
4726 * Also account for superblock, inode, quota and xattr blocks
4727 */
4730 {
4736 /*
4737 * How many index blocks need to touch to map @lblocks logical blocks
4738 * to @pextents physical extents?
4739 */
4744 /*
4745 * Now let's see how many group bitmaps and group descriptors need
4746 * to account
4747 */
4755 /* bitmaps and block group descriptor blocks */
4758 /* Blocks for super block, inode, quota and xattr blocks */
4762 }
4764 /*
4765 * Calculate the total number of credits to reserve to fit
4766 * the modification of a single pages into a single transaction,
4767 * which may include multiple chunks of block allocations.
4768 *
4769 * This could be called via ext4_write_begin()
4770 *
4771 * We need to consider the worse case, when
4772 * one new block per extent.
4773 */
4775 {
4781 /* Account for data blocks for journalled mode */
4785 }
4787 /*
4788 * Calculate the journal credits for a chunk of data modification.
4789 *
4790 * This is called from DIO, fallocate or whoever calling
4791 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4792 *
4793 * journal buffers for data blocks are not included here, as DIO
4794 * and fallocate do no need to journal data buffers.
4795 */
4797 {
4799 }
4801 /*
4802 * The caller must have previously called ext4_reserve_inode_write().
4803 * Give this, we know that the caller already has write access to iloc->bh.
4804 */
4807 {
4813 /* the do_update_inode consumes one bh->b_count */
4816 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4820 }
4822 /*
4823 * On success, We end up with an outstanding reference count against
4824 * iloc->bh. This _must_ be cleaned up later.
4825 */
4827 int
4830 {
4840 }
4841 }
4844 }
4846 /*
4847 * Expand an inode by new_extra_isize bytes.
4848 * Returns 0 on success or negative error number on failure.
4849 */
4854 {
4865 /* No extended attributes present */
4869 new_extra_isize);
4872 }
4874 /* try to expand with EAs present */
4877 }
4879 /*
4880 * What we do here is to mark the in-core inode as clean with respect to inode
4881 * dirtiness (it may still be data-dirty).
4882 * This means that the in-core inode may be reaped by prune_icache
4883 * without having to perform any I/O. This is a very good thing,
4884 * because *any* task may call prune_icache - even ones which
4885 * have a transaction open against a different journal.
4886 *
4887 * Is this cheating? Not really. Sure, we haven't written the
4888 * inode out, but prune_icache isn't a user-visible syncing function.
4889 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4890 * we start and wait on commits.
4891 */
4893 {
4905 /*
4906 * We need extra buffer credits since we may write into EA block
4907 * with this same handle. If journal_extend fails, then it will
4908 * only result in a minor loss of functionality for that inode.
4909 * If this is felt to be critical, then e2fsck should be run to
4910 * force a large enough s_min_extra_isize.
4911 */
4919 EXT4_STATE_NO_EXPAND);
4923 "Unable to expand inode %lu. Delete"
4926 mnt_count =
4928 }
4929 }
4930 }
4931 }
4935 }
4937 /*
4938 * ext4_dirty_inode() is called from __mark_inode_dirty()
4939 *
4940 * We're really interested in the case where a file is being extended.
4941 * i_size has been changed by generic_commit_write() and we thus need
4942 * to include the updated inode in the current transaction.
4943 *
4944 * Also, dquot_alloc_block() will always dirty the inode when blocks
4945 * are allocated to the file.
4946 *
4947 * If the inode is marked synchronous, we don't honour that here - doing
4948 * so would cause a commit on atime updates, which we don't bother doing.
4949 * We handle synchronous inodes at the highest possible level.
4950 */
4952 {
4962 out:
4964 }
4966 #if 0
4967 /*
4968 * Bind an inode's backing buffer_head into this transaction, to prevent
4969 * it from being flushed to disk early. Unlike
4970 * ext4_reserve_inode_write, this leaves behind no bh reference and
4971 * returns no iloc structure, so the caller needs to repeat the iloc
4972 * lookup to mark the inode dirty later.
4973 */
4975 {
4986 NULL,
4989 }
4990 }
4993 }
4994 #endif
4997 {
5002 /*
5003 * We have to be very careful here: changing a data block's
5004 * journaling status dynamically is dangerous. If we write a
5005 * data block to the journal, change the status and then delete
5006 * that block, we risk forgetting to revoke the old log record
5007 * from the journal and so a subsequent replay can corrupt data.
5008 * So, first we make sure that the journal is empty and that
5009 * nobody is changing anything.
5010 */
5017 /* We have to allocate physical blocks for delalloc blocks
5018 * before flushing journal. otherwise delalloc blocks can not
5019 * be allocated any more. even more truncate on delalloc blocks
5020 * could trigger BUG by flushing delalloc blocks in journal.
5021 * There is no delalloc block in non-journal data mode.
5022 */
5027 }
5029 /* Wait for all existing dio workers */
5035 /*
5036 * OK, there are no updates running now, and all cached data is
5037 * synced to disk. We are now in a completely consistent state
5038 * which doesn't have anything in the journal, and we know that
5039 * no filesystem updates are running, so it is safe to modify
5040 * the inode's in-core data-journaling state flag now.
5041 */
5048 }
5054 /* Finally we can mark the inode as dirty. */
5066 }
5069 {
5071 }
5074 {
5076 loff_t size;
5088 /* Delalloc case is easy... */
5094 ext4_da_get_block_prep);
5098 }
5102 /* Page got truncated from under us? */
5107 }
5111 else
5113 /*
5114 * Return if we have all the buffers mapped. This avoids the need to do
5115 * journal_start/journal_stop which can block and take a long time
5116 */
5120 ext4_bh_unmapped)) {
5121 /* Wait so that we don't change page under IO */
5125 }
5126 }
5128 /* OK, we need to fill the hole... */
5131 else
5133 retry_alloc:
5139 }
5148 }
5150 }
5154 out_ret:
5156 out:
5159 }