1ac27a0ecSDave Kleikamp /* 2617ba13bSMingming Cao * linux/fs/ext4/inode.c 3ac27a0ecSDave Kleikamp * 4ac27a0ecSDave Kleikamp * Copyright (C) 1992, 1993, 1994, 1995 5ac27a0ecSDave Kleikamp * Remy Card (card@masi.ibp.fr) 6ac27a0ecSDave Kleikamp * Laboratoire MASI - Institut Blaise Pascal 7ac27a0ecSDave Kleikamp * Universite Pierre et Marie Curie (Paris VI) 8ac27a0ecSDave Kleikamp * 9ac27a0ecSDave Kleikamp * from 10ac27a0ecSDave Kleikamp * 11ac27a0ecSDave Kleikamp * linux/fs/minix/inode.c 12ac27a0ecSDave Kleikamp * 13ac27a0ecSDave Kleikamp * Copyright (C) 1991, 1992 Linus Torvalds 14ac27a0ecSDave Kleikamp * 15ac27a0ecSDave Kleikamp * 64-bit file support on 64-bit platforms by Jakub Jelinek 16ac27a0ecSDave Kleikamp * (jj@sunsite.ms.mff.cuni.cz) 17ac27a0ecSDave Kleikamp * 18617ba13bSMingming Cao * Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000 19ac27a0ecSDave Kleikamp */ 20ac27a0ecSDave Kleikamp 21ac27a0ecSDave Kleikamp #include <linux/fs.h> 22ac27a0ecSDave Kleikamp #include <linux/time.h> 23ac27a0ecSDave Kleikamp #include <linux/highuid.h> 24ac27a0ecSDave Kleikamp #include <linux/pagemap.h> 25c94c2acfSMatthew Wilcox #include <linux/dax.h> 26ac27a0ecSDave Kleikamp #include <linux/quotaops.h> 27ac27a0ecSDave Kleikamp #include <linux/string.h> 28ac27a0ecSDave Kleikamp #include <linux/buffer_head.h> 29ac27a0ecSDave Kleikamp #include <linux/writeback.h> 3064769240SAlex Tomas #include <linux/pagevec.h> 31ac27a0ecSDave Kleikamp #include <linux/mpage.h> 32e83c1397SDuane Griffin #include <linux/namei.h> 33ac27a0ecSDave Kleikamp #include <linux/uio.h> 34ac27a0ecSDave Kleikamp #include <linux/bio.h> 354c0425ffSMingming Cao #include <linux/workqueue.h> 36744692dcSJiaying Zhang #include <linux/kernel.h> 376db26ffcSAndrew Morton #include <linux/printk.h> 385a0e3ad6STejun Heo #include <linux/slab.h> 3900a1a053STheodore Ts'o #include <linux/bitops.h> 409bffad1eSTheodore Ts'o 413dcf5451SChristoph Hellwig #include "ext4_jbd2.h" 42ac27a0ecSDave Kleikamp #include "xattr.h" 43ac27a0ecSDave Kleikamp #include "acl.h" 449f125d64STheodore Ts'o #include "truncate.h" 45ac27a0ecSDave Kleikamp 469bffad1eSTheodore Ts'o #include <trace/events/ext4.h> 479bffad1eSTheodore Ts'o 48a1d6cc56SAneesh Kumar K.V #define MPAGE_DA_EXTENT_TAIL 0x01 49a1d6cc56SAneesh Kumar K.V 50814525f4SDarrick J. Wong static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw, 51814525f4SDarrick J. Wong struct ext4_inode_info *ei) 52814525f4SDarrick J. Wong { 53814525f4SDarrick J. Wong struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 54814525f4SDarrick J. Wong __u16 csum_lo; 55814525f4SDarrick J. Wong __u16 csum_hi = 0; 56814525f4SDarrick J. Wong __u32 csum; 57814525f4SDarrick J. Wong 58171a7f21SDmitry Monakhov csum_lo = le16_to_cpu(raw->i_checksum_lo); 59814525f4SDarrick J. Wong raw->i_checksum_lo = 0; 60814525f4SDarrick J. Wong if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && 61814525f4SDarrick J. Wong EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) { 62171a7f21SDmitry Monakhov csum_hi = le16_to_cpu(raw->i_checksum_hi); 63814525f4SDarrick J. Wong raw->i_checksum_hi = 0; 64814525f4SDarrick J. Wong } 65814525f4SDarrick J. Wong 66814525f4SDarrick J. Wong csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)raw, 67814525f4SDarrick J. Wong EXT4_INODE_SIZE(inode->i_sb)); 68814525f4SDarrick J. Wong 69171a7f21SDmitry Monakhov raw->i_checksum_lo = cpu_to_le16(csum_lo); 70814525f4SDarrick J. Wong if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && 71814525f4SDarrick J. Wong EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) 72171a7f21SDmitry Monakhov raw->i_checksum_hi = cpu_to_le16(csum_hi); 73814525f4SDarrick J. Wong 74814525f4SDarrick J. Wong return csum; 75814525f4SDarrick J. Wong } 76814525f4SDarrick J. Wong 77814525f4SDarrick J. Wong static int ext4_inode_csum_verify(struct inode *inode, struct ext4_inode *raw, 78814525f4SDarrick J. Wong struct ext4_inode_info *ei) 79814525f4SDarrick J. Wong { 80814525f4SDarrick J. Wong __u32 provided, calculated; 81814525f4SDarrick J. Wong 82814525f4SDarrick J. Wong if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != 83814525f4SDarrick J. Wong cpu_to_le32(EXT4_OS_LINUX) || 849aa5d32bSDmitry Monakhov !ext4_has_metadata_csum(inode->i_sb)) 85814525f4SDarrick J. Wong return 1; 86814525f4SDarrick J. Wong 87814525f4SDarrick J. Wong provided = le16_to_cpu(raw->i_checksum_lo); 88814525f4SDarrick J. Wong calculated = ext4_inode_csum(inode, raw, ei); 89814525f4SDarrick J. Wong if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && 90814525f4SDarrick J. Wong EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) 91814525f4SDarrick J. Wong provided |= ((__u32)le16_to_cpu(raw->i_checksum_hi)) << 16; 92814525f4SDarrick J. Wong else 93814525f4SDarrick J. Wong calculated &= 0xFFFF; 94814525f4SDarrick J. Wong 95814525f4SDarrick J. Wong return provided == calculated; 96814525f4SDarrick J. Wong } 97814525f4SDarrick J. Wong 98814525f4SDarrick J. Wong static void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw, 99814525f4SDarrick J. Wong struct ext4_inode_info *ei) 100814525f4SDarrick J. Wong { 101814525f4SDarrick J. Wong __u32 csum; 102814525f4SDarrick J. Wong 103814525f4SDarrick J. Wong if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != 104814525f4SDarrick J. Wong cpu_to_le32(EXT4_OS_LINUX) || 1059aa5d32bSDmitry Monakhov !ext4_has_metadata_csum(inode->i_sb)) 106814525f4SDarrick J. Wong return; 107814525f4SDarrick J. Wong 108814525f4SDarrick J. Wong csum = ext4_inode_csum(inode, raw, ei); 109814525f4SDarrick J. Wong raw->i_checksum_lo = cpu_to_le16(csum & 0xFFFF); 110814525f4SDarrick J. Wong if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && 111814525f4SDarrick J. Wong EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) 112814525f4SDarrick J. Wong raw->i_checksum_hi = cpu_to_le16(csum >> 16); 113814525f4SDarrick J. Wong } 114814525f4SDarrick J. Wong 115678aaf48SJan Kara static inline int ext4_begin_ordered_truncate(struct inode *inode, 116678aaf48SJan Kara loff_t new_size) 117678aaf48SJan Kara { 1187ff9c073STheodore Ts'o trace_ext4_begin_ordered_truncate(inode, new_size); 1198aefcd55STheodore Ts'o /* 1208aefcd55STheodore Ts'o * If jinode is zero, then we never opened the file for 1218aefcd55STheodore Ts'o * writing, so there's no need to call 1228aefcd55STheodore Ts'o * jbd2_journal_begin_ordered_truncate() since there's no 1238aefcd55STheodore Ts'o * outstanding writes we need to flush. 1248aefcd55STheodore Ts'o */ 1258aefcd55STheodore Ts'o if (!EXT4_I(inode)->jinode) 1268aefcd55STheodore Ts'o return 0; 1278aefcd55STheodore Ts'o return jbd2_journal_begin_ordered_truncate(EXT4_JOURNAL(inode), 1288aefcd55STheodore Ts'o EXT4_I(inode)->jinode, 129678aaf48SJan Kara new_size); 130678aaf48SJan Kara } 131678aaf48SJan Kara 132d47992f8SLukas Czerner static void ext4_invalidatepage(struct page *page, unsigned int offset, 133d47992f8SLukas Czerner unsigned int length); 134cb20d518STheodore Ts'o static int __ext4_journalled_writepage(struct page *page, unsigned int len); 135cb20d518STheodore Ts'o static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh); 136fffb2739SJan Kara static int ext4_meta_trans_blocks(struct inode *inode, int lblocks, 137fffb2739SJan Kara int pextents); 13864769240SAlex Tomas 139ac27a0ecSDave Kleikamp /* 140ac27a0ecSDave Kleikamp * Test whether an inode is a fast symlink. 141ac27a0ecSDave Kleikamp */ 142f348c252STheodore Ts'o int ext4_inode_is_fast_symlink(struct inode *inode) 143ac27a0ecSDave Kleikamp { 144617ba13bSMingming Cao int ea_blocks = EXT4_I(inode)->i_file_acl ? 14565eddb56SYongqiang Yang EXT4_CLUSTER_SIZE(inode->i_sb) >> 9 : 0; 146ac27a0ecSDave Kleikamp 147bd9db175SZheng Liu if (ext4_has_inline_data(inode)) 148bd9db175SZheng Liu return 0; 149bd9db175SZheng Liu 150ac27a0ecSDave Kleikamp return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0); 151ac27a0ecSDave Kleikamp } 152ac27a0ecSDave Kleikamp 153ac27a0ecSDave Kleikamp /* 154ac27a0ecSDave Kleikamp * Restart the transaction associated with *handle. This does a commit, 155ac27a0ecSDave Kleikamp * so before we call here everything must be consistently dirtied against 156ac27a0ecSDave Kleikamp * this transaction. 157ac27a0ecSDave Kleikamp */ 158487caeefSJan Kara int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode, 159487caeefSJan Kara int nblocks) 160ac27a0ecSDave Kleikamp { 161487caeefSJan Kara int ret; 162487caeefSJan Kara 163487caeefSJan Kara /* 164e35fd660STheodore Ts'o * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this 165487caeefSJan Kara * moment, get_block can be called only for blocks inside i_size since 166487caeefSJan Kara * page cache has been already dropped and writes are blocked by 167487caeefSJan Kara * i_mutex. So we can safely drop the i_data_sem here. 168487caeefSJan Kara */ 1690390131bSFrank Mayhar BUG_ON(EXT4_JOURNAL(inode) == NULL); 170ac27a0ecSDave Kleikamp jbd_debug(2, "restarting handle %p\n", handle); 171487caeefSJan Kara up_write(&EXT4_I(inode)->i_data_sem); 1728e8eaabeSAmir Goldstein ret = ext4_journal_restart(handle, nblocks); 173487caeefSJan Kara down_write(&EXT4_I(inode)->i_data_sem); 174fa5d1113SAneesh Kumar K.V ext4_discard_preallocations(inode); 175487caeefSJan Kara 176487caeefSJan Kara return ret; 177ac27a0ecSDave Kleikamp } 178ac27a0ecSDave Kleikamp 179ac27a0ecSDave Kleikamp /* 180ac27a0ecSDave Kleikamp * Called at the last iput() if i_nlink is zero. 181ac27a0ecSDave Kleikamp */ 1820930fcc1SAl Viro void ext4_evict_inode(struct inode *inode) 183ac27a0ecSDave Kleikamp { 184ac27a0ecSDave Kleikamp handle_t *handle; 185bc965ab3STheodore Ts'o int err; 186ac27a0ecSDave Kleikamp 1877ff9c073STheodore Ts'o trace_ext4_evict_inode(inode); 1882581fdc8SJiaying Zhang 1890930fcc1SAl Viro if (inode->i_nlink) { 1902d859db3SJan Kara /* 1912d859db3SJan Kara * When journalling data dirty buffers are tracked only in the 1922d859db3SJan Kara * journal. So although mm thinks everything is clean and 1932d859db3SJan Kara * ready for reaping the inode might still have some pages to 1942d859db3SJan Kara * write in the running transaction or waiting to be 1952d859db3SJan Kara * checkpointed. Thus calling jbd2_journal_invalidatepage() 1962d859db3SJan Kara * (via truncate_inode_pages()) to discard these buffers can 1972d859db3SJan Kara * cause data loss. Also even if we did not discard these 1982d859db3SJan Kara * buffers, we would have no way to find them after the inode 1992d859db3SJan Kara * is reaped and thus user could see stale data if he tries to 2002d859db3SJan Kara * read them before the transaction is checkpointed. So be 2012d859db3SJan Kara * careful and force everything to disk here... We use 2022d859db3SJan Kara * ei->i_datasync_tid to store the newest transaction 2032d859db3SJan Kara * containing inode's data. 2042d859db3SJan Kara * 2052d859db3SJan Kara * Note that directories do not have this problem because they 2062d859db3SJan Kara * don't use page cache. 2072d859db3SJan Kara */ 2082d859db3SJan Kara if (ext4_should_journal_data(inode) && 2092b405bfaSTheodore Ts'o (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode)) && 2102b405bfaSTheodore Ts'o inode->i_ino != EXT4_JOURNAL_INO) { 2112d859db3SJan Kara journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; 2122d859db3SJan Kara tid_t commit_tid = EXT4_I(inode)->i_datasync_tid; 2132d859db3SJan Kara 214d76a3a77STheodore Ts'o jbd2_complete_transaction(journal, commit_tid); 2152d859db3SJan Kara filemap_write_and_wait(&inode->i_data); 2162d859db3SJan Kara } 21791b0abe3SJohannes Weiner truncate_inode_pages_final(&inode->i_data); 2185dc23bddSJan Kara 2195dc23bddSJan Kara WARN_ON(atomic_read(&EXT4_I(inode)->i_ioend_count)); 2200930fcc1SAl Viro goto no_delete; 2210930fcc1SAl Viro } 2220930fcc1SAl Viro 223e2bfb088STheodore Ts'o if (is_bad_inode(inode)) 224e2bfb088STheodore Ts'o goto no_delete; 225871a2931SChristoph Hellwig dquot_initialize(inode); 226907f4554SChristoph Hellwig 227678aaf48SJan Kara if (ext4_should_order_data(inode)) 228678aaf48SJan Kara ext4_begin_ordered_truncate(inode, 0); 22991b0abe3SJohannes Weiner truncate_inode_pages_final(&inode->i_data); 230ac27a0ecSDave Kleikamp 2315dc23bddSJan Kara WARN_ON(atomic_read(&EXT4_I(inode)->i_ioend_count)); 232ac27a0ecSDave Kleikamp 2338e8ad8a5SJan Kara /* 2348e8ad8a5SJan Kara * Protect us against freezing - iput() caller didn't have to have any 2358e8ad8a5SJan Kara * protection against it 2368e8ad8a5SJan Kara */ 2378e8ad8a5SJan Kara sb_start_intwrite(inode->i_sb); 2389924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, 2399924a92aSTheodore Ts'o ext4_blocks_for_truncate(inode)+3); 240ac27a0ecSDave Kleikamp if (IS_ERR(handle)) { 241bc965ab3STheodore Ts'o ext4_std_error(inode->i_sb, PTR_ERR(handle)); 242ac27a0ecSDave Kleikamp /* 243ac27a0ecSDave Kleikamp * If we're going to skip the normal cleanup, we still need to 244ac27a0ecSDave Kleikamp * make sure that the in-core orphan linked list is properly 245ac27a0ecSDave Kleikamp * cleaned up. 246ac27a0ecSDave Kleikamp */ 247617ba13bSMingming Cao ext4_orphan_del(NULL, inode); 2488e8ad8a5SJan Kara sb_end_intwrite(inode->i_sb); 249ac27a0ecSDave Kleikamp goto no_delete; 250ac27a0ecSDave Kleikamp } 251ac27a0ecSDave Kleikamp 252ac27a0ecSDave Kleikamp if (IS_SYNC(inode)) 2530390131bSFrank Mayhar ext4_handle_sync(handle); 254ac27a0ecSDave Kleikamp inode->i_size = 0; 255bc965ab3STheodore Ts'o err = ext4_mark_inode_dirty(handle, inode); 256bc965ab3STheodore Ts'o if (err) { 25712062dddSEric Sandeen ext4_warning(inode->i_sb, 258bc965ab3STheodore Ts'o "couldn't mark inode dirty (err %d)", err); 259bc965ab3STheodore Ts'o goto stop_handle; 260bc965ab3STheodore Ts'o } 261ac27a0ecSDave Kleikamp if (inode->i_blocks) 262617ba13bSMingming Cao ext4_truncate(inode); 263bc965ab3STheodore Ts'o 264bc965ab3STheodore Ts'o /* 265bc965ab3STheodore Ts'o * ext4_ext_truncate() doesn't reserve any slop when it 266bc965ab3STheodore Ts'o * restarts journal transactions; therefore there may not be 267bc965ab3STheodore Ts'o * enough credits left in the handle to remove the inode from 268bc965ab3STheodore Ts'o * the orphan list and set the dtime field. 269bc965ab3STheodore Ts'o */ 2700390131bSFrank Mayhar if (!ext4_handle_has_enough_credits(handle, 3)) { 271bc965ab3STheodore Ts'o err = ext4_journal_extend(handle, 3); 272bc965ab3STheodore Ts'o if (err > 0) 273bc965ab3STheodore Ts'o err = ext4_journal_restart(handle, 3); 274bc965ab3STheodore Ts'o if (err != 0) { 27512062dddSEric Sandeen ext4_warning(inode->i_sb, 276bc965ab3STheodore Ts'o "couldn't extend journal (err %d)", err); 277bc965ab3STheodore Ts'o stop_handle: 278bc965ab3STheodore Ts'o ext4_journal_stop(handle); 27945388219STheodore Ts'o ext4_orphan_del(NULL, inode); 2808e8ad8a5SJan Kara sb_end_intwrite(inode->i_sb); 281bc965ab3STheodore Ts'o goto no_delete; 282bc965ab3STheodore Ts'o } 283bc965ab3STheodore Ts'o } 284bc965ab3STheodore Ts'o 285ac27a0ecSDave Kleikamp /* 286617ba13bSMingming Cao * Kill off the orphan record which ext4_truncate created. 287ac27a0ecSDave Kleikamp * AKPM: I think this can be inside the above `if'. 288617ba13bSMingming Cao * Note that ext4_orphan_del() has to be able to cope with the 289ac27a0ecSDave Kleikamp * deletion of a non-existent orphan - this is because we don't 290617ba13bSMingming Cao * know if ext4_truncate() actually created an orphan record. 291ac27a0ecSDave Kleikamp * (Well, we could do this if we need to, but heck - it works) 292ac27a0ecSDave Kleikamp */ 293617ba13bSMingming Cao ext4_orphan_del(handle, inode); 294617ba13bSMingming Cao EXT4_I(inode)->i_dtime = get_seconds(); 295ac27a0ecSDave Kleikamp 296ac27a0ecSDave Kleikamp /* 297ac27a0ecSDave Kleikamp * One subtle ordering requirement: if anything has gone wrong 298ac27a0ecSDave Kleikamp * (transaction abort, IO errors, whatever), then we can still 299ac27a0ecSDave Kleikamp * do these next steps (the fs will already have been marked as 300ac27a0ecSDave Kleikamp * having errors), but we can't free the inode if the mark_dirty 301ac27a0ecSDave Kleikamp * fails. 302ac27a0ecSDave Kleikamp */ 303617ba13bSMingming Cao if (ext4_mark_inode_dirty(handle, inode)) 304ac27a0ecSDave Kleikamp /* If that failed, just do the required in-core inode clear. */ 3050930fcc1SAl Viro ext4_clear_inode(inode); 306ac27a0ecSDave Kleikamp else 307617ba13bSMingming Cao ext4_free_inode(handle, inode); 308617ba13bSMingming Cao ext4_journal_stop(handle); 3098e8ad8a5SJan Kara sb_end_intwrite(inode->i_sb); 310ac27a0ecSDave Kleikamp return; 311ac27a0ecSDave Kleikamp no_delete: 3120930fcc1SAl Viro ext4_clear_inode(inode); /* We must guarantee clearing of inode... */ 313ac27a0ecSDave Kleikamp } 314ac27a0ecSDave Kleikamp 315a9e7f447SDmitry Monakhov #ifdef CONFIG_QUOTA 316a9e7f447SDmitry Monakhov qsize_t *ext4_get_reserved_space(struct inode *inode) 31760e58e0fSMingming Cao { 318a9e7f447SDmitry Monakhov return &EXT4_I(inode)->i_reserved_quota; 31960e58e0fSMingming Cao } 320a9e7f447SDmitry Monakhov #endif 3219d0be502STheodore Ts'o 32212219aeaSAneesh Kumar K.V /* 3230637c6f4STheodore Ts'o * Called with i_data_sem down, which is important since we can call 3240637c6f4STheodore Ts'o * ext4_discard_preallocations() from here. 3250637c6f4STheodore Ts'o */ 3265f634d06SAneesh Kumar K.V void ext4_da_update_reserve_space(struct inode *inode, 3275f634d06SAneesh Kumar K.V int used, int quota_claim) 32812219aeaSAneesh Kumar K.V { 32912219aeaSAneesh Kumar K.V struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 3300637c6f4STheodore Ts'o struct ext4_inode_info *ei = EXT4_I(inode); 33112219aeaSAneesh Kumar K.V 3320637c6f4STheodore Ts'o spin_lock(&ei->i_block_reservation_lock); 333d8990240SAditya Kali trace_ext4_da_update_reserve_space(inode, used, quota_claim); 3340637c6f4STheodore Ts'o if (unlikely(used > ei->i_reserved_data_blocks)) { 3358de5c325STheodore Ts'o ext4_warning(inode->i_sb, "%s: ino %lu, used %d " 3361084f252STheodore Ts'o "with only %d reserved data blocks", 3370637c6f4STheodore Ts'o __func__, inode->i_ino, used, 3380637c6f4STheodore Ts'o ei->i_reserved_data_blocks); 3390637c6f4STheodore Ts'o WARN_ON(1); 3400637c6f4STheodore Ts'o used = ei->i_reserved_data_blocks; 3416bc6e63fSAneesh Kumar K.V } 34212219aeaSAneesh Kumar K.V 3430637c6f4STheodore Ts'o /* Update per-inode reservations */ 3440637c6f4STheodore Ts'o ei->i_reserved_data_blocks -= used; 34571d4f7d0STheodore Ts'o percpu_counter_sub(&sbi->s_dirtyclusters_counter, used); 3460637c6f4STheodore Ts'o 34712219aeaSAneesh Kumar K.V spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 34860e58e0fSMingming Cao 34972b8ab9dSEric Sandeen /* Update quota subsystem for data blocks */ 35072b8ab9dSEric Sandeen if (quota_claim) 3517b415bf6SAditya Kali dquot_claim_block(inode, EXT4_C2B(sbi, used)); 35272b8ab9dSEric Sandeen else { 3535f634d06SAneesh Kumar K.V /* 3545f634d06SAneesh Kumar K.V * We did fallocate with an offset that is already delayed 3555f634d06SAneesh Kumar K.V * allocated. So on delayed allocated writeback we should 35672b8ab9dSEric Sandeen * not re-claim the quota for fallocated blocks. 3575f634d06SAneesh Kumar K.V */ 3587b415bf6SAditya Kali dquot_release_reservation_block(inode, EXT4_C2B(sbi, used)); 3595f634d06SAneesh Kumar K.V } 360d6014301SAneesh Kumar K.V 361d6014301SAneesh Kumar K.V /* 362d6014301SAneesh Kumar K.V * If we have done all the pending block allocations and if 363d6014301SAneesh Kumar K.V * there aren't any writers on the inode, we can discard the 364d6014301SAneesh Kumar K.V * inode's preallocations. 365d6014301SAneesh Kumar K.V */ 3660637c6f4STheodore Ts'o if ((ei->i_reserved_data_blocks == 0) && 3670637c6f4STheodore Ts'o (atomic_read(&inode->i_writecount) == 0)) 368d6014301SAneesh Kumar K.V ext4_discard_preallocations(inode); 36912219aeaSAneesh Kumar K.V } 37012219aeaSAneesh Kumar K.V 371e29136f8STheodore Ts'o static int __check_block_validity(struct inode *inode, const char *func, 372c398eda0STheodore Ts'o unsigned int line, 37324676da4STheodore Ts'o struct ext4_map_blocks *map) 3746fd058f7STheodore Ts'o { 37524676da4STheodore Ts'o if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk, 37624676da4STheodore Ts'o map->m_len)) { 377c398eda0STheodore Ts'o ext4_error_inode(inode, func, line, map->m_pblk, 378c398eda0STheodore Ts'o "lblock %lu mapped to illegal pblock " 37924676da4STheodore Ts'o "(length %d)", (unsigned long) map->m_lblk, 380c398eda0STheodore Ts'o map->m_len); 3816a797d27SDarrick J. Wong return -EFSCORRUPTED; 3826fd058f7STheodore Ts'o } 3836fd058f7STheodore Ts'o return 0; 3846fd058f7STheodore Ts'o } 3856fd058f7STheodore Ts'o 38653085facSJan Kara int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk, 38753085facSJan Kara ext4_lblk_t len) 38853085facSJan Kara { 38953085facSJan Kara int ret; 39053085facSJan Kara 39153085facSJan Kara if (ext4_encrypted_inode(inode)) 39253085facSJan Kara return ext4_encrypted_zeroout(inode, lblk, pblk, len); 39353085facSJan Kara 39453085facSJan Kara ret = sb_issue_zeroout(inode->i_sb, pblk, len, GFP_NOFS); 39553085facSJan Kara if (ret > 0) 39653085facSJan Kara ret = 0; 39753085facSJan Kara 39853085facSJan Kara return ret; 39953085facSJan Kara } 40053085facSJan Kara 401e29136f8STheodore Ts'o #define check_block_validity(inode, map) \ 402c398eda0STheodore Ts'o __check_block_validity((inode), __func__, __LINE__, (map)) 403e29136f8STheodore Ts'o 404921f266bSDmitry Monakhov #ifdef ES_AGGRESSIVE_TEST 405921f266bSDmitry Monakhov static void ext4_map_blocks_es_recheck(handle_t *handle, 406921f266bSDmitry Monakhov struct inode *inode, 407921f266bSDmitry Monakhov struct ext4_map_blocks *es_map, 408921f266bSDmitry Monakhov struct ext4_map_blocks *map, 409921f266bSDmitry Monakhov int flags) 410921f266bSDmitry Monakhov { 411921f266bSDmitry Monakhov int retval; 412921f266bSDmitry Monakhov 413921f266bSDmitry Monakhov map->m_flags = 0; 414921f266bSDmitry Monakhov /* 415921f266bSDmitry Monakhov * There is a race window that the result is not the same. 416921f266bSDmitry Monakhov * e.g. xfstests #223 when dioread_nolock enables. The reason 417921f266bSDmitry Monakhov * is that we lookup a block mapping in extent status tree with 418921f266bSDmitry Monakhov * out taking i_data_sem. So at the time the unwritten extent 419921f266bSDmitry Monakhov * could be converted. 420921f266bSDmitry Monakhov */ 421c8b459f4SLukas Czerner down_read(&EXT4_I(inode)->i_data_sem); 422921f266bSDmitry Monakhov if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 423921f266bSDmitry Monakhov retval = ext4_ext_map_blocks(handle, inode, map, flags & 424921f266bSDmitry Monakhov EXT4_GET_BLOCKS_KEEP_SIZE); 425921f266bSDmitry Monakhov } else { 426921f266bSDmitry Monakhov retval = ext4_ind_map_blocks(handle, inode, map, flags & 427921f266bSDmitry Monakhov EXT4_GET_BLOCKS_KEEP_SIZE); 428921f266bSDmitry Monakhov } 429921f266bSDmitry Monakhov up_read((&EXT4_I(inode)->i_data_sem)); 430921f266bSDmitry Monakhov 431921f266bSDmitry Monakhov /* 432921f266bSDmitry Monakhov * We don't check m_len because extent will be collpased in status 433921f266bSDmitry Monakhov * tree. So the m_len might not equal. 434921f266bSDmitry Monakhov */ 435921f266bSDmitry Monakhov if (es_map->m_lblk != map->m_lblk || 436921f266bSDmitry Monakhov es_map->m_flags != map->m_flags || 437921f266bSDmitry Monakhov es_map->m_pblk != map->m_pblk) { 438bdafe42aSTheodore Ts'o printk("ES cache assertion failed for inode: %lu " 439921f266bSDmitry Monakhov "es_cached ex [%d/%d/%llu/%x] != " 440921f266bSDmitry Monakhov "found ex [%d/%d/%llu/%x] retval %d flags %x\n", 441921f266bSDmitry Monakhov inode->i_ino, es_map->m_lblk, es_map->m_len, 442921f266bSDmitry Monakhov es_map->m_pblk, es_map->m_flags, map->m_lblk, 443921f266bSDmitry Monakhov map->m_len, map->m_pblk, map->m_flags, 444921f266bSDmitry Monakhov retval, flags); 445921f266bSDmitry Monakhov } 446921f266bSDmitry Monakhov } 447921f266bSDmitry Monakhov #endif /* ES_AGGRESSIVE_TEST */ 448921f266bSDmitry Monakhov 44955138e0bSTheodore Ts'o /* 450e35fd660STheodore Ts'o * The ext4_map_blocks() function tries to look up the requested blocks, 4512b2d6d01STheodore Ts'o * and returns if the blocks are already mapped. 452f5ab0d1fSMingming Cao * 453f5ab0d1fSMingming Cao * Otherwise it takes the write lock of the i_data_sem and allocate blocks 454f5ab0d1fSMingming Cao * and store the allocated blocks in the result buffer head and mark it 455f5ab0d1fSMingming Cao * mapped. 456f5ab0d1fSMingming Cao * 457e35fd660STheodore Ts'o * If file type is extents based, it will call ext4_ext_map_blocks(), 458e35fd660STheodore Ts'o * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping 459f5ab0d1fSMingming Cao * based files 460f5ab0d1fSMingming Cao * 461556615dcSLukas Czerner * On success, it returns the number of blocks being mapped or allocated. 462556615dcSLukas Czerner * if create==0 and the blocks are pre-allocated and unwritten block, 463f5ab0d1fSMingming Cao * the result buffer head is unmapped. If the create ==1, it will make sure 464f5ab0d1fSMingming Cao * the buffer head is mapped. 465f5ab0d1fSMingming Cao * 466f5ab0d1fSMingming Cao * It returns 0 if plain look up failed (blocks have not been allocated), in 467df3ab170STao Ma * that case, buffer head is unmapped 468f5ab0d1fSMingming Cao * 469f5ab0d1fSMingming Cao * It returns the error in case of allocation failure. 470f5ab0d1fSMingming Cao */ 471e35fd660STheodore Ts'o int ext4_map_blocks(handle_t *handle, struct inode *inode, 472e35fd660STheodore Ts'o struct ext4_map_blocks *map, int flags) 4730e855ac8SAneesh Kumar K.V { 474d100eef2SZheng Liu struct extent_status es; 4750e855ac8SAneesh Kumar K.V int retval; 476b8a86845SLukas Czerner int ret = 0; 477921f266bSDmitry Monakhov #ifdef ES_AGGRESSIVE_TEST 478921f266bSDmitry Monakhov struct ext4_map_blocks orig_map; 479921f266bSDmitry Monakhov 480921f266bSDmitry Monakhov memcpy(&orig_map, map, sizeof(*map)); 481921f266bSDmitry Monakhov #endif 482f5ab0d1fSMingming Cao 483e35fd660STheodore Ts'o map->m_flags = 0; 484e35fd660STheodore Ts'o ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u," 485e35fd660STheodore Ts'o "logical block %lu\n", inode->i_ino, flags, map->m_len, 486e35fd660STheodore Ts'o (unsigned long) map->m_lblk); 487d100eef2SZheng Liu 488e861b5e9STheodore Ts'o /* 489e861b5e9STheodore Ts'o * ext4_map_blocks returns an int, and m_len is an unsigned int 490e861b5e9STheodore Ts'o */ 491e861b5e9STheodore Ts'o if (unlikely(map->m_len > INT_MAX)) 492e861b5e9STheodore Ts'o map->m_len = INT_MAX; 493e861b5e9STheodore Ts'o 4944adb6ab3SKazuya Mio /* We can handle the block number less than EXT_MAX_BLOCKS */ 4954adb6ab3SKazuya Mio if (unlikely(map->m_lblk >= EXT_MAX_BLOCKS)) 4966a797d27SDarrick J. Wong return -EFSCORRUPTED; 4974adb6ab3SKazuya Mio 498d100eef2SZheng Liu /* Lookup extent status tree firstly */ 499d100eef2SZheng Liu if (ext4_es_lookup_extent(inode, map->m_lblk, &es)) { 500d100eef2SZheng Liu if (ext4_es_is_written(&es) || ext4_es_is_unwritten(&es)) { 501d100eef2SZheng Liu map->m_pblk = ext4_es_pblock(&es) + 502d100eef2SZheng Liu map->m_lblk - es.es_lblk; 503d100eef2SZheng Liu map->m_flags |= ext4_es_is_written(&es) ? 504d100eef2SZheng Liu EXT4_MAP_MAPPED : EXT4_MAP_UNWRITTEN; 505d100eef2SZheng Liu retval = es.es_len - (map->m_lblk - es.es_lblk); 506d100eef2SZheng Liu if (retval > map->m_len) 507d100eef2SZheng Liu retval = map->m_len; 508d100eef2SZheng Liu map->m_len = retval; 509d100eef2SZheng Liu } else if (ext4_es_is_delayed(&es) || ext4_es_is_hole(&es)) { 510d100eef2SZheng Liu retval = 0; 511d100eef2SZheng Liu } else { 512d100eef2SZheng Liu BUG_ON(1); 513d100eef2SZheng Liu } 514921f266bSDmitry Monakhov #ifdef ES_AGGRESSIVE_TEST 515921f266bSDmitry Monakhov ext4_map_blocks_es_recheck(handle, inode, map, 516921f266bSDmitry Monakhov &orig_map, flags); 517921f266bSDmitry Monakhov #endif 518d100eef2SZheng Liu goto found; 519d100eef2SZheng Liu } 520d100eef2SZheng Liu 5214df3d265SAneesh Kumar K.V /* 522b920c755STheodore Ts'o * Try to see if we can get the block without requesting a new 523b920c755STheodore Ts'o * file system block. 5244df3d265SAneesh Kumar K.V */ 525c8b459f4SLukas Czerner down_read(&EXT4_I(inode)->i_data_sem); 52612e9b892SDmitry Monakhov if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 527a4e5d88bSDmitry Monakhov retval = ext4_ext_map_blocks(handle, inode, map, flags & 528a4e5d88bSDmitry Monakhov EXT4_GET_BLOCKS_KEEP_SIZE); 5294df3d265SAneesh Kumar K.V } else { 530a4e5d88bSDmitry Monakhov retval = ext4_ind_map_blocks(handle, inode, map, flags & 531a4e5d88bSDmitry Monakhov EXT4_GET_BLOCKS_KEEP_SIZE); 5320e855ac8SAneesh Kumar K.V } 533f7fec032SZheng Liu if (retval > 0) { 5343be78c73STheodore Ts'o unsigned int status; 535f7fec032SZheng Liu 53644fb851dSZheng Liu if (unlikely(retval != map->m_len)) { 53744fb851dSZheng Liu ext4_warning(inode->i_sb, 53844fb851dSZheng Liu "ES len assertion failed for inode " 53944fb851dSZheng Liu "%lu: retval %d != map->m_len %d", 54044fb851dSZheng Liu inode->i_ino, retval, map->m_len); 54144fb851dSZheng Liu WARN_ON(1); 542921f266bSDmitry Monakhov } 543921f266bSDmitry Monakhov 544f7fec032SZheng Liu status = map->m_flags & EXT4_MAP_UNWRITTEN ? 545f7fec032SZheng Liu EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN; 546f7fec032SZheng Liu if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) && 547d2dc317dSLukas Czerner !(status & EXTENT_STATUS_WRITTEN) && 548f7fec032SZheng Liu ext4_find_delalloc_range(inode, map->m_lblk, 549f7fec032SZheng Liu map->m_lblk + map->m_len - 1)) 550f7fec032SZheng Liu status |= EXTENT_STATUS_DELAYED; 551f7fec032SZheng Liu ret = ext4_es_insert_extent(inode, map->m_lblk, 552f7fec032SZheng Liu map->m_len, map->m_pblk, status); 553f7fec032SZheng Liu if (ret < 0) 554f7fec032SZheng Liu retval = ret; 555f7fec032SZheng Liu } 5564df3d265SAneesh Kumar K.V up_read((&EXT4_I(inode)->i_data_sem)); 557f5ab0d1fSMingming Cao 558d100eef2SZheng Liu found: 559e35fd660STheodore Ts'o if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) { 560b8a86845SLukas Czerner ret = check_block_validity(inode, map); 5616fd058f7STheodore Ts'o if (ret != 0) 5626fd058f7STheodore Ts'o return ret; 5636fd058f7STheodore Ts'o } 5646fd058f7STheodore Ts'o 565f5ab0d1fSMingming Cao /* If it is only a block(s) look up */ 566c2177057STheodore Ts'o if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) 5674df3d265SAneesh Kumar K.V return retval; 5684df3d265SAneesh Kumar K.V 5694df3d265SAneesh Kumar K.V /* 570f5ab0d1fSMingming Cao * Returns if the blocks have already allocated 571f5ab0d1fSMingming Cao * 572f5ab0d1fSMingming Cao * Note that if blocks have been preallocated 573df3ab170STao Ma * ext4_ext_get_block() returns the create = 0 574f5ab0d1fSMingming Cao * with buffer head unmapped. 575f5ab0d1fSMingming Cao */ 576e35fd660STheodore Ts'o if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) 577b8a86845SLukas Czerner /* 578b8a86845SLukas Czerner * If we need to convert extent to unwritten 579b8a86845SLukas Czerner * we continue and do the actual work in 580b8a86845SLukas Czerner * ext4_ext_map_blocks() 581b8a86845SLukas Czerner */ 582b8a86845SLukas Czerner if (!(flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN)) 583f5ab0d1fSMingming Cao return retval; 584f5ab0d1fSMingming Cao 585f5ab0d1fSMingming Cao /* 586a25a4e1aSZheng Liu * Here we clear m_flags because after allocating an new extent, 587a25a4e1aSZheng Liu * it will be set again. 5882a8964d6SAneesh Kumar K.V */ 589a25a4e1aSZheng Liu map->m_flags &= ~EXT4_MAP_FLAGS; 5902a8964d6SAneesh Kumar K.V 5912a8964d6SAneesh Kumar K.V /* 592556615dcSLukas Czerner * New blocks allocate and/or writing to unwritten extent 593f5ab0d1fSMingming Cao * will possibly result in updating i_data, so we take 594d91bd2c1SSeunghun Lee * the write lock of i_data_sem, and call get_block() 595f5ab0d1fSMingming Cao * with create == 1 flag. 5964df3d265SAneesh Kumar K.V */ 597c8b459f4SLukas Czerner down_write(&EXT4_I(inode)->i_data_sem); 598d2a17637SMingming Cao 599d2a17637SMingming Cao /* 6004df3d265SAneesh Kumar K.V * We need to check for EXT4 here because migrate 6014df3d265SAneesh Kumar K.V * could have changed the inode type in between 6024df3d265SAneesh Kumar K.V */ 60312e9b892SDmitry Monakhov if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 604e35fd660STheodore Ts'o retval = ext4_ext_map_blocks(handle, inode, map, flags); 6050e855ac8SAneesh Kumar K.V } else { 606e35fd660STheodore Ts'o retval = ext4_ind_map_blocks(handle, inode, map, flags); 607267e4db9SAneesh Kumar K.V 608e35fd660STheodore Ts'o if (retval > 0 && map->m_flags & EXT4_MAP_NEW) { 609267e4db9SAneesh Kumar K.V /* 610267e4db9SAneesh Kumar K.V * We allocated new blocks which will result in 611267e4db9SAneesh Kumar K.V * i_data's format changing. Force the migrate 612267e4db9SAneesh Kumar K.V * to fail by clearing migrate flags 613267e4db9SAneesh Kumar K.V */ 61419f5fb7aSTheodore Ts'o ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE); 615267e4db9SAneesh Kumar K.V } 6162ac3b6e0STheodore Ts'o 617d2a17637SMingming Cao /* 6182ac3b6e0STheodore Ts'o * Update reserved blocks/metadata blocks after successful 6195f634d06SAneesh Kumar K.V * block allocation which had been deferred till now. We don't 6205f634d06SAneesh Kumar K.V * support fallocate for non extent files. So we can update 6215f634d06SAneesh Kumar K.V * reserve space here. 622d2a17637SMingming Cao */ 6235f634d06SAneesh Kumar K.V if ((retval > 0) && 6241296cc85SAneesh Kumar K.V (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)) 6255f634d06SAneesh Kumar K.V ext4_da_update_reserve_space(inode, retval, 1); 6265f634d06SAneesh Kumar K.V } 627d2a17637SMingming Cao 628f7fec032SZheng Liu if (retval > 0) { 6293be78c73STheodore Ts'o unsigned int status; 630f7fec032SZheng Liu 63144fb851dSZheng Liu if (unlikely(retval != map->m_len)) { 63244fb851dSZheng Liu ext4_warning(inode->i_sb, 63344fb851dSZheng Liu "ES len assertion failed for inode " 63444fb851dSZheng Liu "%lu: retval %d != map->m_len %d", 63544fb851dSZheng Liu inode->i_ino, retval, map->m_len); 63644fb851dSZheng Liu WARN_ON(1); 637921f266bSDmitry Monakhov } 638921f266bSDmitry Monakhov 639adb23551SZheng Liu /* 640c86d8db3SJan Kara * We have to zeroout blocks before inserting them into extent 641c86d8db3SJan Kara * status tree. Otherwise someone could look them up there and 642c86d8db3SJan Kara * use them before they are really zeroed. 643c86d8db3SJan Kara */ 644c86d8db3SJan Kara if (flags & EXT4_GET_BLOCKS_ZERO && 645c86d8db3SJan Kara map->m_flags & EXT4_MAP_MAPPED && 646c86d8db3SJan Kara map->m_flags & EXT4_MAP_NEW) { 647c86d8db3SJan Kara ret = ext4_issue_zeroout(inode, map->m_lblk, 648c86d8db3SJan Kara map->m_pblk, map->m_len); 649c86d8db3SJan Kara if (ret) { 650c86d8db3SJan Kara retval = ret; 651c86d8db3SJan Kara goto out_sem; 652c86d8db3SJan Kara } 653c86d8db3SJan Kara } 654c86d8db3SJan Kara 655c86d8db3SJan Kara /* 656adb23551SZheng Liu * If the extent has been zeroed out, we don't need to update 657adb23551SZheng Liu * extent status tree. 658adb23551SZheng Liu */ 659adb23551SZheng Liu if ((flags & EXT4_GET_BLOCKS_PRE_IO) && 660adb23551SZheng Liu ext4_es_lookup_extent(inode, map->m_lblk, &es)) { 661adb23551SZheng Liu if (ext4_es_is_written(&es)) 662c86d8db3SJan Kara goto out_sem; 663adb23551SZheng Liu } 664f7fec032SZheng Liu status = map->m_flags & EXT4_MAP_UNWRITTEN ? 665f7fec032SZheng Liu EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN; 666f7fec032SZheng Liu if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) && 667d2dc317dSLukas Czerner !(status & EXTENT_STATUS_WRITTEN) && 668f7fec032SZheng Liu ext4_find_delalloc_range(inode, map->m_lblk, 669f7fec032SZheng Liu map->m_lblk + map->m_len - 1)) 670f7fec032SZheng Liu status |= EXTENT_STATUS_DELAYED; 671f7fec032SZheng Liu ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len, 672f7fec032SZheng Liu map->m_pblk, status); 673c86d8db3SJan Kara if (ret < 0) { 67451865fdaSZheng Liu retval = ret; 675c86d8db3SJan Kara goto out_sem; 676c86d8db3SJan Kara } 67751865fdaSZheng Liu } 6785356f261SAditya Kali 679c86d8db3SJan Kara out_sem: 6800e855ac8SAneesh Kumar K.V up_write((&EXT4_I(inode)->i_data_sem)); 681e35fd660STheodore Ts'o if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) { 682b8a86845SLukas Czerner ret = check_block_validity(inode, map); 6836fd058f7STheodore Ts'o if (ret != 0) 6846fd058f7STheodore Ts'o return ret; 6856fd058f7STheodore Ts'o } 6860e855ac8SAneesh Kumar K.V return retval; 6870e855ac8SAneesh Kumar K.V } 6880e855ac8SAneesh Kumar K.V 689ed8ad838SJan Kara /* 690ed8ad838SJan Kara * Update EXT4_MAP_FLAGS in bh->b_state. For buffer heads attached to pages 691ed8ad838SJan Kara * we have to be careful as someone else may be manipulating b_state as well. 692ed8ad838SJan Kara */ 693ed8ad838SJan Kara static void ext4_update_bh_state(struct buffer_head *bh, unsigned long flags) 694ed8ad838SJan Kara { 695ed8ad838SJan Kara unsigned long old_state; 696ed8ad838SJan Kara unsigned long new_state; 697ed8ad838SJan Kara 698ed8ad838SJan Kara flags &= EXT4_MAP_FLAGS; 699ed8ad838SJan Kara 700ed8ad838SJan Kara /* Dummy buffer_head? Set non-atomically. */ 701ed8ad838SJan Kara if (!bh->b_page) { 702ed8ad838SJan Kara bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | flags; 703ed8ad838SJan Kara return; 704ed8ad838SJan Kara } 705ed8ad838SJan Kara /* 706ed8ad838SJan Kara * Someone else may be modifying b_state. Be careful! This is ugly but 707ed8ad838SJan Kara * once we get rid of using bh as a container for mapping information 708ed8ad838SJan Kara * to pass to / from get_block functions, this can go away. 709ed8ad838SJan Kara */ 710ed8ad838SJan Kara do { 711ed8ad838SJan Kara old_state = READ_ONCE(bh->b_state); 712ed8ad838SJan Kara new_state = (old_state & ~EXT4_MAP_FLAGS) | flags; 713ed8ad838SJan Kara } while (unlikely( 714ed8ad838SJan Kara cmpxchg(&bh->b_state, old_state, new_state) != old_state)); 715ed8ad838SJan Kara } 716ed8ad838SJan Kara 7172ed88685STheodore Ts'o static int _ext4_get_block(struct inode *inode, sector_t iblock, 7182ed88685STheodore Ts'o struct buffer_head *bh, int flags) 719ac27a0ecSDave Kleikamp { 7202ed88685STheodore Ts'o struct ext4_map_blocks map; 721efe70c29SJan Kara int ret = 0; 722ac27a0ecSDave Kleikamp 72346c7f254STao Ma if (ext4_has_inline_data(inode)) 72446c7f254STao Ma return -ERANGE; 72546c7f254STao Ma 7262ed88685STheodore Ts'o map.m_lblk = iblock; 7272ed88685STheodore Ts'o map.m_len = bh->b_size >> inode->i_blkbits; 7282ed88685STheodore Ts'o 729efe70c29SJan Kara ret = ext4_map_blocks(ext4_journal_current_handle(), inode, &map, 730efe70c29SJan Kara flags); 731ac27a0ecSDave Kleikamp if (ret > 0) { 7322ed88685STheodore Ts'o map_bh(bh, inode->i_sb, map.m_pblk); 733ed8ad838SJan Kara ext4_update_bh_state(bh, map.m_flags); 7342ed88685STheodore Ts'o bh->b_size = inode->i_sb->s_blocksize * map.m_len; 735ac27a0ecSDave Kleikamp ret = 0; 736ac27a0ecSDave Kleikamp } 737ac27a0ecSDave Kleikamp return ret; 738ac27a0ecSDave Kleikamp } 739ac27a0ecSDave Kleikamp 7402ed88685STheodore Ts'o int ext4_get_block(struct inode *inode, sector_t iblock, 7412ed88685STheodore Ts'o struct buffer_head *bh, int create) 7422ed88685STheodore Ts'o { 7432ed88685STheodore Ts'o return _ext4_get_block(inode, iblock, bh, 7442ed88685STheodore Ts'o create ? EXT4_GET_BLOCKS_CREATE : 0); 7452ed88685STheodore Ts'o } 7462ed88685STheodore Ts'o 747ac27a0ecSDave Kleikamp /* 748705965bdSJan Kara * Get block function used when preparing for buffered write if we require 749705965bdSJan Kara * creating an unwritten extent if blocks haven't been allocated. The extent 750705965bdSJan Kara * will be converted to written after the IO is complete. 751705965bdSJan Kara */ 752705965bdSJan Kara int ext4_get_block_unwritten(struct inode *inode, sector_t iblock, 753705965bdSJan Kara struct buffer_head *bh_result, int create) 754705965bdSJan Kara { 755705965bdSJan Kara ext4_debug("ext4_get_block_unwritten: inode %lu, create flag %d\n", 756705965bdSJan Kara inode->i_ino, create); 757705965bdSJan Kara return _ext4_get_block(inode, iblock, bh_result, 758705965bdSJan Kara EXT4_GET_BLOCKS_IO_CREATE_EXT); 759705965bdSJan Kara } 760705965bdSJan Kara 761efe70c29SJan Kara /* Maximum number of blocks we map for direct IO at once. */ 762efe70c29SJan Kara #define DIO_MAX_BLOCKS 4096 763efe70c29SJan Kara 764efe70c29SJan Kara static handle_t *start_dio_trans(struct inode *inode, 765efe70c29SJan Kara struct buffer_head *bh_result) 766efe70c29SJan Kara { 767efe70c29SJan Kara int dio_credits; 768efe70c29SJan Kara 769efe70c29SJan Kara /* Trim mapping request to maximum we can map at once for DIO */ 770efe70c29SJan Kara if (bh_result->b_size >> inode->i_blkbits > DIO_MAX_BLOCKS) 771efe70c29SJan Kara bh_result->b_size = DIO_MAX_BLOCKS << inode->i_blkbits; 772efe70c29SJan Kara dio_credits = ext4_chunk_trans_blocks(inode, 773efe70c29SJan Kara bh_result->b_size >> inode->i_blkbits); 774efe70c29SJan Kara return ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, dio_credits); 775efe70c29SJan Kara } 776efe70c29SJan Kara 777705965bdSJan Kara /* Get block function for DIO reads and writes to inodes without extents */ 778705965bdSJan Kara int ext4_dio_get_block(struct inode *inode, sector_t iblock, 779705965bdSJan Kara struct buffer_head *bh, int create) 780705965bdSJan Kara { 781efe70c29SJan Kara handle_t *handle; 782efe70c29SJan Kara int ret; 783efe70c29SJan Kara 784efe70c29SJan Kara /* We don't expect handle for direct IO */ 785efe70c29SJan Kara WARN_ON_ONCE(ext4_journal_current_handle()); 786efe70c29SJan Kara 787efe70c29SJan Kara if (create) { 788efe70c29SJan Kara handle = start_dio_trans(inode, bh); 789efe70c29SJan Kara if (IS_ERR(handle)) 790efe70c29SJan Kara return PTR_ERR(handle); 791efe70c29SJan Kara } 792efe70c29SJan Kara ret = _ext4_get_block(inode, iblock, bh, 793705965bdSJan Kara create ? EXT4_GET_BLOCKS_CREATE : 0); 794efe70c29SJan Kara if (create) 795efe70c29SJan Kara ext4_journal_stop(handle); 796efe70c29SJan Kara return ret; 797705965bdSJan Kara } 798705965bdSJan Kara 799705965bdSJan Kara /* 800*109811c2SJan Kara * Get block function for AIO DIO writes when we create unwritten extent if 801705965bdSJan Kara * blocks are not allocated yet. The extent will be converted to written 802705965bdSJan Kara * after IO is complete. 803705965bdSJan Kara */ 804*109811c2SJan Kara static int ext4_dio_get_block_unwritten_async(struct inode *inode, 805*109811c2SJan Kara sector_t iblock, struct buffer_head *bh_result, int create) 806705965bdSJan Kara { 807efe70c29SJan Kara handle_t *handle; 808efe70c29SJan Kara int ret; 809efe70c29SJan Kara 810efe70c29SJan Kara /* We don't expect handle for direct IO */ 811efe70c29SJan Kara WARN_ON_ONCE(ext4_journal_current_handle()); 812efe70c29SJan Kara 813efe70c29SJan Kara handle = start_dio_trans(inode, bh_result); 814efe70c29SJan Kara if (IS_ERR(handle)) 815efe70c29SJan Kara return PTR_ERR(handle); 816efe70c29SJan Kara ret = _ext4_get_block(inode, iblock, bh_result, 817705965bdSJan Kara EXT4_GET_BLOCKS_IO_CREATE_EXT); 818efe70c29SJan Kara ext4_journal_stop(handle); 819efe70c29SJan Kara 820*109811c2SJan Kara /* 821*109811c2SJan Kara * When doing DIO using unwritten extents, we need io_end to convert 822*109811c2SJan Kara * unwritten extents to written on IO completion. We allocate io_end 823*109811c2SJan Kara * once we spot unwritten extent and store it in b_private. Generic 824*109811c2SJan Kara * DIO code keeps b_private set and furthermore passes the value to 825*109811c2SJan Kara * our completion callback in 'private' argument. 826*109811c2SJan Kara */ 827*109811c2SJan Kara if (!ret && buffer_unwritten(bh_result)) { 828*109811c2SJan Kara if (!bh_result->b_private) { 829*109811c2SJan Kara ext4_io_end_t *io_end; 830*109811c2SJan Kara 831*109811c2SJan Kara io_end = ext4_init_io_end(inode, GFP_KERNEL); 832*109811c2SJan Kara if (!io_end) 833*109811c2SJan Kara return -ENOMEM; 834*109811c2SJan Kara bh_result->b_private = io_end; 835*109811c2SJan Kara ext4_set_io_unwritten_flag(inode, io_end); 836efe70c29SJan Kara } 837*109811c2SJan Kara set_buffer_defer_completion(bh_result); 838*109811c2SJan Kara } 839*109811c2SJan Kara 840*109811c2SJan Kara return ret; 841*109811c2SJan Kara } 842*109811c2SJan Kara 843*109811c2SJan Kara /* 844*109811c2SJan Kara * Get block function for non-AIO DIO writes when we create unwritten extent if 845*109811c2SJan Kara * blocks are not allocated yet. The extent will be converted to written 846*109811c2SJan Kara * after IO is complete from ext4_ext_direct_IO() function. 847*109811c2SJan Kara */ 848*109811c2SJan Kara static int ext4_dio_get_block_unwritten_sync(struct inode *inode, 849*109811c2SJan Kara sector_t iblock, struct buffer_head *bh_result, int create) 850*109811c2SJan Kara { 851*109811c2SJan Kara handle_t *handle; 852*109811c2SJan Kara int ret; 853*109811c2SJan Kara 854*109811c2SJan Kara /* We don't expect handle for direct IO */ 855*109811c2SJan Kara WARN_ON_ONCE(ext4_journal_current_handle()); 856*109811c2SJan Kara 857*109811c2SJan Kara handle = start_dio_trans(inode, bh_result); 858*109811c2SJan Kara if (IS_ERR(handle)) 859*109811c2SJan Kara return PTR_ERR(handle); 860*109811c2SJan Kara ret = _ext4_get_block(inode, iblock, bh_result, 861*109811c2SJan Kara EXT4_GET_BLOCKS_IO_CREATE_EXT); 862*109811c2SJan Kara ext4_journal_stop(handle); 863*109811c2SJan Kara 864*109811c2SJan Kara /* 865*109811c2SJan Kara * Mark inode as having pending DIO writes to unwritten extents. 866*109811c2SJan Kara * ext4_ext_direct_IO() checks this flag and converts extents to 867*109811c2SJan Kara * written. 868*109811c2SJan Kara */ 869*109811c2SJan Kara if (!ret && buffer_unwritten(bh_result)) 870*109811c2SJan Kara ext4_set_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN); 871efe70c29SJan Kara 872efe70c29SJan Kara return ret; 873705965bdSJan Kara } 874705965bdSJan Kara 875705965bdSJan Kara static int ext4_dio_get_block_overwrite(struct inode *inode, sector_t iblock, 876705965bdSJan Kara struct buffer_head *bh_result, int create) 877705965bdSJan Kara { 878705965bdSJan Kara int ret; 879705965bdSJan Kara 880705965bdSJan Kara ext4_debug("ext4_dio_get_block_overwrite: inode %lu, create flag %d\n", 881705965bdSJan Kara inode->i_ino, create); 882efe70c29SJan Kara /* We don't expect handle for direct IO */ 883efe70c29SJan Kara WARN_ON_ONCE(ext4_journal_current_handle()); 884efe70c29SJan Kara 885705965bdSJan Kara ret = _ext4_get_block(inode, iblock, bh_result, 0); 886705965bdSJan Kara /* 887705965bdSJan Kara * Blocks should have been preallocated! ext4_file_write_iter() checks 888705965bdSJan Kara * that. 889705965bdSJan Kara */ 890efe70c29SJan Kara WARN_ON_ONCE(!buffer_mapped(bh_result) || buffer_unwritten(bh_result)); 891705965bdSJan Kara 892705965bdSJan Kara return ret; 893705965bdSJan Kara } 894705965bdSJan Kara 895705965bdSJan Kara 896705965bdSJan Kara /* 897ac27a0ecSDave Kleikamp * `handle' can be NULL if create is zero 898ac27a0ecSDave Kleikamp */ 899617ba13bSMingming Cao struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode, 900c5e298aeSTheodore Ts'o ext4_lblk_t block, int map_flags) 901ac27a0ecSDave Kleikamp { 9022ed88685STheodore Ts'o struct ext4_map_blocks map; 9032ed88685STheodore Ts'o struct buffer_head *bh; 904c5e298aeSTheodore Ts'o int create = map_flags & EXT4_GET_BLOCKS_CREATE; 90510560082STheodore Ts'o int err; 906ac27a0ecSDave Kleikamp 907ac27a0ecSDave Kleikamp J_ASSERT(handle != NULL || create == 0); 908ac27a0ecSDave Kleikamp 9092ed88685STheodore Ts'o map.m_lblk = block; 9102ed88685STheodore Ts'o map.m_len = 1; 911c5e298aeSTheodore Ts'o err = ext4_map_blocks(handle, inode, &map, map_flags); 9122ed88685STheodore Ts'o 91310560082STheodore Ts'o if (err == 0) 91410560082STheodore Ts'o return create ? ERR_PTR(-ENOSPC) : NULL; 9152ed88685STheodore Ts'o if (err < 0) 91610560082STheodore Ts'o return ERR_PTR(err); 9172ed88685STheodore Ts'o 9182ed88685STheodore Ts'o bh = sb_getblk(inode->i_sb, map.m_pblk); 91910560082STheodore Ts'o if (unlikely(!bh)) 92010560082STheodore Ts'o return ERR_PTR(-ENOMEM); 9212ed88685STheodore Ts'o if (map.m_flags & EXT4_MAP_NEW) { 922ac27a0ecSDave Kleikamp J_ASSERT(create != 0); 923ac39849dSAneesh Kumar K.V J_ASSERT(handle != NULL); 924ac27a0ecSDave Kleikamp 925ac27a0ecSDave Kleikamp /* 926ac27a0ecSDave Kleikamp * Now that we do not always journal data, we should 927ac27a0ecSDave Kleikamp * keep in mind whether this should always journal the 928ac27a0ecSDave Kleikamp * new buffer as metadata. For now, regular file 929617ba13bSMingming Cao * writes use ext4_get_block instead, so it's not a 930ac27a0ecSDave Kleikamp * problem. 931ac27a0ecSDave Kleikamp */ 932ac27a0ecSDave Kleikamp lock_buffer(bh); 933ac27a0ecSDave Kleikamp BUFFER_TRACE(bh, "call get_create_access"); 93410560082STheodore Ts'o err = ext4_journal_get_create_access(handle, bh); 93510560082STheodore Ts'o if (unlikely(err)) { 93610560082STheodore Ts'o unlock_buffer(bh); 93710560082STheodore Ts'o goto errout; 93810560082STheodore Ts'o } 93910560082STheodore Ts'o if (!buffer_uptodate(bh)) { 940ac27a0ecSDave Kleikamp memset(bh->b_data, 0, inode->i_sb->s_blocksize); 941ac27a0ecSDave Kleikamp set_buffer_uptodate(bh); 942ac27a0ecSDave Kleikamp } 943ac27a0ecSDave Kleikamp unlock_buffer(bh); 9440390131bSFrank Mayhar BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); 9450390131bSFrank Mayhar err = ext4_handle_dirty_metadata(handle, inode, bh); 94610560082STheodore Ts'o if (unlikely(err)) 94710560082STheodore Ts'o goto errout; 94810560082STheodore Ts'o } else 949ac27a0ecSDave Kleikamp BUFFER_TRACE(bh, "not a new buffer"); 950ac27a0ecSDave Kleikamp return bh; 95110560082STheodore Ts'o errout: 95210560082STheodore Ts'o brelse(bh); 95310560082STheodore Ts'o return ERR_PTR(err); 954ac27a0ecSDave Kleikamp } 955ac27a0ecSDave Kleikamp 956617ba13bSMingming Cao struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode, 957c5e298aeSTheodore Ts'o ext4_lblk_t block, int map_flags) 958ac27a0ecSDave Kleikamp { 959ac27a0ecSDave Kleikamp struct buffer_head *bh; 960ac27a0ecSDave Kleikamp 961c5e298aeSTheodore Ts'o bh = ext4_getblk(handle, inode, block, map_flags); 9621c215028STheodore Ts'o if (IS_ERR(bh)) 963ac27a0ecSDave Kleikamp return bh; 9641c215028STheodore Ts'o if (!bh || buffer_uptodate(bh)) 965ac27a0ecSDave Kleikamp return bh; 96665299a3bSChristoph Hellwig ll_rw_block(READ | REQ_META | REQ_PRIO, 1, &bh); 967ac27a0ecSDave Kleikamp wait_on_buffer(bh); 968ac27a0ecSDave Kleikamp if (buffer_uptodate(bh)) 969ac27a0ecSDave Kleikamp return bh; 970ac27a0ecSDave Kleikamp put_bh(bh); 9711c215028STheodore Ts'o return ERR_PTR(-EIO); 972ac27a0ecSDave Kleikamp } 973ac27a0ecSDave Kleikamp 974f19d5870STao Ma int ext4_walk_page_buffers(handle_t *handle, 975ac27a0ecSDave Kleikamp struct buffer_head *head, 976ac27a0ecSDave Kleikamp unsigned from, 977ac27a0ecSDave Kleikamp unsigned to, 978ac27a0ecSDave Kleikamp int *partial, 979ac27a0ecSDave Kleikamp int (*fn)(handle_t *handle, 980ac27a0ecSDave Kleikamp struct buffer_head *bh)) 981ac27a0ecSDave Kleikamp { 982ac27a0ecSDave Kleikamp struct buffer_head *bh; 983ac27a0ecSDave Kleikamp unsigned block_start, block_end; 984ac27a0ecSDave Kleikamp unsigned blocksize = head->b_size; 985ac27a0ecSDave Kleikamp int err, ret = 0; 986ac27a0ecSDave Kleikamp struct buffer_head *next; 987ac27a0ecSDave Kleikamp 988ac27a0ecSDave Kleikamp for (bh = head, block_start = 0; 989ac27a0ecSDave Kleikamp ret == 0 && (bh != head || !block_start); 990de9a55b8STheodore Ts'o block_start = block_end, bh = next) { 991ac27a0ecSDave Kleikamp next = bh->b_this_page; 992ac27a0ecSDave Kleikamp block_end = block_start + blocksize; 993ac27a0ecSDave Kleikamp if (block_end <= from || block_start >= to) { 994ac27a0ecSDave Kleikamp if (partial && !buffer_uptodate(bh)) 995ac27a0ecSDave Kleikamp *partial = 1; 996ac27a0ecSDave Kleikamp continue; 997ac27a0ecSDave Kleikamp } 998ac27a0ecSDave Kleikamp err = (*fn)(handle, bh); 999ac27a0ecSDave Kleikamp if (!ret) 1000ac27a0ecSDave Kleikamp ret = err; 1001ac27a0ecSDave Kleikamp } 1002ac27a0ecSDave Kleikamp return ret; 1003ac27a0ecSDave Kleikamp } 1004ac27a0ecSDave Kleikamp 1005ac27a0ecSDave Kleikamp /* 1006ac27a0ecSDave Kleikamp * To preserve ordering, it is essential that the hole instantiation and 1007ac27a0ecSDave Kleikamp * the data write be encapsulated in a single transaction. We cannot 1008617ba13bSMingming Cao * close off a transaction and start a new one between the ext4_get_block() 1009dab291afSMingming Cao * and the commit_write(). So doing the jbd2_journal_start at the start of 1010ac27a0ecSDave Kleikamp * prepare_write() is the right place. 1011ac27a0ecSDave Kleikamp * 101236ade451SJan Kara * Also, this function can nest inside ext4_writepage(). In that case, we 101336ade451SJan Kara * *know* that ext4_writepage() has generated enough buffer credits to do the 101436ade451SJan Kara * whole page. So we won't block on the journal in that case, which is good, 101536ade451SJan Kara * because the caller may be PF_MEMALLOC. 1016ac27a0ecSDave Kleikamp * 1017617ba13bSMingming Cao * By accident, ext4 can be reentered when a transaction is open via 1018ac27a0ecSDave Kleikamp * quota file writes. If we were to commit the transaction while thus 1019ac27a0ecSDave Kleikamp * reentered, there can be a deadlock - we would be holding a quota 1020ac27a0ecSDave Kleikamp * lock, and the commit would never complete if another thread had a 1021ac27a0ecSDave Kleikamp * transaction open and was blocking on the quota lock - a ranking 1022ac27a0ecSDave Kleikamp * violation. 1023ac27a0ecSDave Kleikamp * 1024dab291afSMingming Cao * So what we do is to rely on the fact that jbd2_journal_stop/journal_start 1025ac27a0ecSDave Kleikamp * will _not_ run commit under these circumstances because handle->h_ref 1026ac27a0ecSDave Kleikamp * is elevated. We'll still have enough credits for the tiny quotafile 1027ac27a0ecSDave Kleikamp * write. 1028ac27a0ecSDave Kleikamp */ 1029f19d5870STao Ma int do_journal_get_write_access(handle_t *handle, 1030ac27a0ecSDave Kleikamp struct buffer_head *bh) 1031ac27a0ecSDave Kleikamp { 103256d35a4cSJan Kara int dirty = buffer_dirty(bh); 103356d35a4cSJan Kara int ret; 103456d35a4cSJan Kara 1035ac27a0ecSDave Kleikamp if (!buffer_mapped(bh) || buffer_freed(bh)) 1036ac27a0ecSDave Kleikamp return 0; 103756d35a4cSJan Kara /* 1038ebdec241SChristoph Hellwig * __block_write_begin() could have dirtied some buffers. Clean 103956d35a4cSJan Kara * the dirty bit as jbd2_journal_get_write_access() could complain 104056d35a4cSJan Kara * otherwise about fs integrity issues. Setting of the dirty bit 1041ebdec241SChristoph Hellwig * by __block_write_begin() isn't a real problem here as we clear 104256d35a4cSJan Kara * the bit before releasing a page lock and thus writeback cannot 104356d35a4cSJan Kara * ever write the buffer. 104456d35a4cSJan Kara */ 104556d35a4cSJan Kara if (dirty) 104656d35a4cSJan Kara clear_buffer_dirty(bh); 10475d601255Sliang xie BUFFER_TRACE(bh, "get write access"); 104856d35a4cSJan Kara ret = ext4_journal_get_write_access(handle, bh); 104956d35a4cSJan Kara if (!ret && dirty) 105056d35a4cSJan Kara ret = ext4_handle_dirty_metadata(handle, NULL, bh); 105156d35a4cSJan Kara return ret; 1052ac27a0ecSDave Kleikamp } 1053ac27a0ecSDave Kleikamp 10542058f83aSMichael Halcrow #ifdef CONFIG_EXT4_FS_ENCRYPTION 10552058f83aSMichael Halcrow static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len, 10562058f83aSMichael Halcrow get_block_t *get_block) 10572058f83aSMichael Halcrow { 10582058f83aSMichael Halcrow unsigned from = pos & (PAGE_CACHE_SIZE - 1); 10592058f83aSMichael Halcrow unsigned to = from + len; 10602058f83aSMichael Halcrow struct inode *inode = page->mapping->host; 10612058f83aSMichael Halcrow unsigned block_start, block_end; 10622058f83aSMichael Halcrow sector_t block; 10632058f83aSMichael Halcrow int err = 0; 10642058f83aSMichael Halcrow unsigned blocksize = inode->i_sb->s_blocksize; 10652058f83aSMichael Halcrow unsigned bbits; 10662058f83aSMichael Halcrow struct buffer_head *bh, *head, *wait[2], **wait_bh = wait; 10672058f83aSMichael Halcrow bool decrypt = false; 10682058f83aSMichael Halcrow 10692058f83aSMichael Halcrow BUG_ON(!PageLocked(page)); 10702058f83aSMichael Halcrow BUG_ON(from > PAGE_CACHE_SIZE); 10712058f83aSMichael Halcrow BUG_ON(to > PAGE_CACHE_SIZE); 10722058f83aSMichael Halcrow BUG_ON(from > to); 10732058f83aSMichael Halcrow 10742058f83aSMichael Halcrow if (!page_has_buffers(page)) 10752058f83aSMichael Halcrow create_empty_buffers(page, blocksize, 0); 10762058f83aSMichael Halcrow head = page_buffers(page); 10772058f83aSMichael Halcrow bbits = ilog2(blocksize); 10782058f83aSMichael Halcrow block = (sector_t)page->index << (PAGE_CACHE_SHIFT - bbits); 10792058f83aSMichael Halcrow 10802058f83aSMichael Halcrow for (bh = head, block_start = 0; bh != head || !block_start; 10812058f83aSMichael Halcrow block++, block_start = block_end, bh = bh->b_this_page) { 10822058f83aSMichael Halcrow block_end = block_start + blocksize; 10832058f83aSMichael Halcrow if (block_end <= from || block_start >= to) { 10842058f83aSMichael Halcrow if (PageUptodate(page)) { 10852058f83aSMichael Halcrow if (!buffer_uptodate(bh)) 10862058f83aSMichael Halcrow set_buffer_uptodate(bh); 10872058f83aSMichael Halcrow } 10882058f83aSMichael Halcrow continue; 10892058f83aSMichael Halcrow } 10902058f83aSMichael Halcrow if (buffer_new(bh)) 10912058f83aSMichael Halcrow clear_buffer_new(bh); 10922058f83aSMichael Halcrow if (!buffer_mapped(bh)) { 10932058f83aSMichael Halcrow WARN_ON(bh->b_size != blocksize); 10942058f83aSMichael Halcrow err = get_block(inode, block, bh, 1); 10952058f83aSMichael Halcrow if (err) 10962058f83aSMichael Halcrow break; 10972058f83aSMichael Halcrow if (buffer_new(bh)) { 10982058f83aSMichael Halcrow unmap_underlying_metadata(bh->b_bdev, 10992058f83aSMichael Halcrow bh->b_blocknr); 11002058f83aSMichael Halcrow if (PageUptodate(page)) { 11012058f83aSMichael Halcrow clear_buffer_new(bh); 11022058f83aSMichael Halcrow set_buffer_uptodate(bh); 11032058f83aSMichael Halcrow mark_buffer_dirty(bh); 11042058f83aSMichael Halcrow continue; 11052058f83aSMichael Halcrow } 11062058f83aSMichael Halcrow if (block_end > to || block_start < from) 11072058f83aSMichael Halcrow zero_user_segments(page, to, block_end, 11082058f83aSMichael Halcrow block_start, from); 11092058f83aSMichael Halcrow continue; 11102058f83aSMichael Halcrow } 11112058f83aSMichael Halcrow } 11122058f83aSMichael Halcrow if (PageUptodate(page)) { 11132058f83aSMichael Halcrow if (!buffer_uptodate(bh)) 11142058f83aSMichael Halcrow set_buffer_uptodate(bh); 11152058f83aSMichael Halcrow continue; 11162058f83aSMichael Halcrow } 11172058f83aSMichael Halcrow if (!buffer_uptodate(bh) && !buffer_delay(bh) && 11182058f83aSMichael Halcrow !buffer_unwritten(bh) && 11192058f83aSMichael Halcrow (block_start < from || block_end > to)) { 11202058f83aSMichael Halcrow ll_rw_block(READ, 1, &bh); 11212058f83aSMichael Halcrow *wait_bh++ = bh; 11222058f83aSMichael Halcrow decrypt = ext4_encrypted_inode(inode) && 11232058f83aSMichael Halcrow S_ISREG(inode->i_mode); 11242058f83aSMichael Halcrow } 11252058f83aSMichael Halcrow } 11262058f83aSMichael Halcrow /* 11272058f83aSMichael Halcrow * If we issued read requests, let them complete. 11282058f83aSMichael Halcrow */ 11292058f83aSMichael Halcrow while (wait_bh > wait) { 11302058f83aSMichael Halcrow wait_on_buffer(*--wait_bh); 11312058f83aSMichael Halcrow if (!buffer_uptodate(*wait_bh)) 11322058f83aSMichael Halcrow err = -EIO; 11332058f83aSMichael Halcrow } 11342058f83aSMichael Halcrow if (unlikely(err)) 11352058f83aSMichael Halcrow page_zero_new_buffers(page, from, to); 11362058f83aSMichael Halcrow else if (decrypt) 11373684de8cSTheodore Ts'o err = ext4_decrypt(page); 11382058f83aSMichael Halcrow return err; 11392058f83aSMichael Halcrow } 11402058f83aSMichael Halcrow #endif 11412058f83aSMichael Halcrow 1142bfc1af65SNick Piggin static int ext4_write_begin(struct file *file, struct address_space *mapping, 1143bfc1af65SNick Piggin loff_t pos, unsigned len, unsigned flags, 1144bfc1af65SNick Piggin struct page **pagep, void **fsdata) 1145ac27a0ecSDave Kleikamp { 1146bfc1af65SNick Piggin struct inode *inode = mapping->host; 11471938a150SAneesh Kumar K.V int ret, needed_blocks; 1148ac27a0ecSDave Kleikamp handle_t *handle; 1149ac27a0ecSDave Kleikamp int retries = 0; 1150bfc1af65SNick Piggin struct page *page; 1151bfc1af65SNick Piggin pgoff_t index; 1152bfc1af65SNick Piggin unsigned from, to; 1153bfc1af65SNick Piggin 11549bffad1eSTheodore Ts'o trace_ext4_write_begin(inode, pos, len, flags); 11551938a150SAneesh Kumar K.V /* 11561938a150SAneesh Kumar K.V * Reserve one block more for addition to orphan list in case 11571938a150SAneesh Kumar K.V * we allocate blocks but write fails for some reason 11581938a150SAneesh Kumar K.V */ 11591938a150SAneesh Kumar K.V needed_blocks = ext4_writepage_trans_blocks(inode) + 1; 1160bfc1af65SNick Piggin index = pos >> PAGE_CACHE_SHIFT; 1161bfc1af65SNick Piggin from = pos & (PAGE_CACHE_SIZE - 1); 1162bfc1af65SNick Piggin to = from + len; 1163ac27a0ecSDave Kleikamp 1164f19d5870STao Ma if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) { 1165f19d5870STao Ma ret = ext4_try_to_write_inline_data(mapping, inode, pos, len, 1166f19d5870STao Ma flags, pagep); 1167f19d5870STao Ma if (ret < 0) 116847564bfbSTheodore Ts'o return ret; 116947564bfbSTheodore Ts'o if (ret == 1) 117047564bfbSTheodore Ts'o return 0; 1171f19d5870STao Ma } 1172f19d5870STao Ma 117347564bfbSTheodore Ts'o /* 117447564bfbSTheodore Ts'o * grab_cache_page_write_begin() can take a long time if the 117547564bfbSTheodore Ts'o * system is thrashing due to memory pressure, or if the page 117647564bfbSTheodore Ts'o * is being written back. So grab it first before we start 117747564bfbSTheodore Ts'o * the transaction handle. This also allows us to allocate 117847564bfbSTheodore Ts'o * the page (if needed) without using GFP_NOFS. 117947564bfbSTheodore Ts'o */ 118047564bfbSTheodore Ts'o retry_grab: 118154566b2cSNick Piggin page = grab_cache_page_write_begin(mapping, index, flags); 118247564bfbSTheodore Ts'o if (!page) 118347564bfbSTheodore Ts'o return -ENOMEM; 118447564bfbSTheodore Ts'o unlock_page(page); 118547564bfbSTheodore Ts'o 118647564bfbSTheodore Ts'o retry_journal: 11879924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks); 1188ac27a0ecSDave Kleikamp if (IS_ERR(handle)) { 118947564bfbSTheodore Ts'o page_cache_release(page); 119047564bfbSTheodore Ts'o return PTR_ERR(handle); 1191cf108bcaSJan Kara } 1192f19d5870STao Ma 119347564bfbSTheodore Ts'o lock_page(page); 119447564bfbSTheodore Ts'o if (page->mapping != mapping) { 119547564bfbSTheodore Ts'o /* The page got truncated from under us */ 119647564bfbSTheodore Ts'o unlock_page(page); 119747564bfbSTheodore Ts'o page_cache_release(page); 1198cf108bcaSJan Kara ext4_journal_stop(handle); 119947564bfbSTheodore Ts'o goto retry_grab; 1200cf108bcaSJan Kara } 12017afe5aa5SDmitry Monakhov /* In case writeback began while the page was unlocked */ 12027afe5aa5SDmitry Monakhov wait_for_stable_page(page); 1203cf108bcaSJan Kara 12042058f83aSMichael Halcrow #ifdef CONFIG_EXT4_FS_ENCRYPTION 12052058f83aSMichael Halcrow if (ext4_should_dioread_nolock(inode)) 12062058f83aSMichael Halcrow ret = ext4_block_write_begin(page, pos, len, 1207705965bdSJan Kara ext4_get_block_unwritten); 12082058f83aSMichael Halcrow else 12092058f83aSMichael Halcrow ret = ext4_block_write_begin(page, pos, len, 12102058f83aSMichael Halcrow ext4_get_block); 12112058f83aSMichael Halcrow #else 1212744692dcSJiaying Zhang if (ext4_should_dioread_nolock(inode)) 1213705965bdSJan Kara ret = __block_write_begin(page, pos, len, 1214705965bdSJan Kara ext4_get_block_unwritten); 1215744692dcSJiaying Zhang else 12166e1db88dSChristoph Hellwig ret = __block_write_begin(page, pos, len, ext4_get_block); 12172058f83aSMichael Halcrow #endif 1218bfc1af65SNick Piggin if (!ret && ext4_should_journal_data(inode)) { 1219f19d5870STao Ma ret = ext4_walk_page_buffers(handle, page_buffers(page), 1220f19d5870STao Ma from, to, NULL, 1221f19d5870STao Ma do_journal_get_write_access); 1222b46be050SAndrey Savochkin } 1223bfc1af65SNick Piggin 1224bfc1af65SNick Piggin if (ret) { 1225bfc1af65SNick Piggin unlock_page(page); 1226ae4d5372SAneesh Kumar K.V /* 12276e1db88dSChristoph Hellwig * __block_write_begin may have instantiated a few blocks 1228ae4d5372SAneesh Kumar K.V * outside i_size. Trim these off again. Don't need 1229ae4d5372SAneesh Kumar K.V * i_size_read because we hold i_mutex. 12301938a150SAneesh Kumar K.V * 12311938a150SAneesh Kumar K.V * Add inode to orphan list in case we crash before 12321938a150SAneesh Kumar K.V * truncate finishes 1233ae4d5372SAneesh Kumar K.V */ 1234ffacfa7aSJan Kara if (pos + len > inode->i_size && ext4_can_truncate(inode)) 12351938a150SAneesh Kumar K.V ext4_orphan_add(handle, inode); 12361938a150SAneesh Kumar K.V 12371938a150SAneesh Kumar K.V ext4_journal_stop(handle); 12381938a150SAneesh Kumar K.V if (pos + len > inode->i_size) { 1239b9a4207dSJan Kara ext4_truncate_failed_write(inode); 12401938a150SAneesh Kumar K.V /* 1241ffacfa7aSJan Kara * If truncate failed early the inode might 12421938a150SAneesh Kumar K.V * still be on the orphan list; we need to 12431938a150SAneesh Kumar K.V * make sure the inode is removed from the 12441938a150SAneesh Kumar K.V * orphan list in that case. 12451938a150SAneesh Kumar K.V */ 12461938a150SAneesh Kumar K.V if (inode->i_nlink) 12471938a150SAneesh Kumar K.V ext4_orphan_del(NULL, inode); 12481938a150SAneesh Kumar K.V } 1249bfc1af65SNick Piggin 125047564bfbSTheodore Ts'o if (ret == -ENOSPC && 125147564bfbSTheodore Ts'o ext4_should_retry_alloc(inode->i_sb, &retries)) 125247564bfbSTheodore Ts'o goto retry_journal; 125347564bfbSTheodore Ts'o page_cache_release(page); 125447564bfbSTheodore Ts'o return ret; 125547564bfbSTheodore Ts'o } 125647564bfbSTheodore Ts'o *pagep = page; 1257ac27a0ecSDave Kleikamp return ret; 1258ac27a0ecSDave Kleikamp } 1259ac27a0ecSDave Kleikamp 1260bfc1af65SNick Piggin /* For write_end() in data=journal mode */ 1261bfc1af65SNick Piggin static int write_end_fn(handle_t *handle, struct buffer_head *bh) 1262ac27a0ecSDave Kleikamp { 126313fca323STheodore Ts'o int ret; 1264ac27a0ecSDave Kleikamp if (!buffer_mapped(bh) || buffer_freed(bh)) 1265ac27a0ecSDave Kleikamp return 0; 1266ac27a0ecSDave Kleikamp set_buffer_uptodate(bh); 126713fca323STheodore Ts'o ret = ext4_handle_dirty_metadata(handle, NULL, bh); 126813fca323STheodore Ts'o clear_buffer_meta(bh); 126913fca323STheodore Ts'o clear_buffer_prio(bh); 127013fca323STheodore Ts'o return ret; 1271ac27a0ecSDave Kleikamp } 1272ac27a0ecSDave Kleikamp 1273eed4333fSZheng Liu /* 1274eed4333fSZheng Liu * We need to pick up the new inode size which generic_commit_write gave us 1275eed4333fSZheng Liu * `file' can be NULL - eg, when called from page_symlink(). 1276eed4333fSZheng Liu * 1277eed4333fSZheng Liu * ext4 never places buffers on inode->i_mapping->private_list. metadata 1278eed4333fSZheng Liu * buffers are managed internally. 1279eed4333fSZheng Liu */ 1280eed4333fSZheng Liu static int ext4_write_end(struct file *file, 1281f8514083SAneesh Kumar K.V struct address_space *mapping, 1282f8514083SAneesh Kumar K.V loff_t pos, unsigned len, unsigned copied, 1283f8514083SAneesh Kumar K.V struct page *page, void *fsdata) 1284f8514083SAneesh Kumar K.V { 1285f8514083SAneesh Kumar K.V handle_t *handle = ext4_journal_current_handle(); 1286eed4333fSZheng Liu struct inode *inode = mapping->host; 12870572639fSXiaoguang Wang loff_t old_size = inode->i_size; 1288eed4333fSZheng Liu int ret = 0, ret2; 1289eed4333fSZheng Liu int i_size_changed = 0; 1290eed4333fSZheng Liu 1291eed4333fSZheng Liu trace_ext4_write_end(inode, pos, len, copied); 1292eed4333fSZheng Liu if (ext4_test_inode_state(inode, EXT4_STATE_ORDERED_MODE)) { 1293eed4333fSZheng Liu ret = ext4_jbd2_file_inode(handle, inode); 1294eed4333fSZheng Liu if (ret) { 1295eed4333fSZheng Liu unlock_page(page); 1296eed4333fSZheng Liu page_cache_release(page); 1297eed4333fSZheng Liu goto errout; 1298eed4333fSZheng Liu } 1299eed4333fSZheng Liu } 1300f8514083SAneesh Kumar K.V 130142c832deSTheodore Ts'o if (ext4_has_inline_data(inode)) { 130242c832deSTheodore Ts'o ret = ext4_write_inline_data_end(inode, pos, len, 1303f19d5870STao Ma copied, page); 130442c832deSTheodore Ts'o if (ret < 0) 130542c832deSTheodore Ts'o goto errout; 130642c832deSTheodore Ts'o copied = ret; 130742c832deSTheodore Ts'o } else 1308f19d5870STao Ma copied = block_write_end(file, mapping, pos, 1309f19d5870STao Ma len, copied, page, fsdata); 1310f8514083SAneesh Kumar K.V /* 13114631dbf6SDmitry Monakhov * it's important to update i_size while still holding page lock: 1312f8514083SAneesh Kumar K.V * page writeout could otherwise come in and zero beyond i_size. 1313f8514083SAneesh Kumar K.V */ 13144631dbf6SDmitry Monakhov i_size_changed = ext4_update_inode_size(inode, pos + copied); 1315f8514083SAneesh Kumar K.V unlock_page(page); 1316f8514083SAneesh Kumar K.V page_cache_release(page); 1317f8514083SAneesh Kumar K.V 13180572639fSXiaoguang Wang if (old_size < pos) 13190572639fSXiaoguang Wang pagecache_isize_extended(inode, old_size, pos); 1320f8514083SAneesh Kumar K.V /* 1321f8514083SAneesh Kumar K.V * Don't mark the inode dirty under page lock. First, it unnecessarily 1322f8514083SAneesh Kumar K.V * makes the holding time of page lock longer. Second, it forces lock 1323f8514083SAneesh Kumar K.V * ordering of page lock and transaction start for journaling 1324f8514083SAneesh Kumar K.V * filesystems. 1325f8514083SAneesh Kumar K.V */ 1326f8514083SAneesh Kumar K.V if (i_size_changed) 1327f8514083SAneesh Kumar K.V ext4_mark_inode_dirty(handle, inode); 1328f8514083SAneesh Kumar K.V 1329ffacfa7aSJan Kara if (pos + len > inode->i_size && ext4_can_truncate(inode)) 1330f8514083SAneesh Kumar K.V /* if we have allocated more blocks and copied 1331f8514083SAneesh Kumar K.V * less. We will have blocks allocated outside 1332f8514083SAneesh Kumar K.V * inode->i_size. So truncate them 1333f8514083SAneesh Kumar K.V */ 1334f8514083SAneesh Kumar K.V ext4_orphan_add(handle, inode); 133574d553aaSTheodore Ts'o errout: 1336617ba13bSMingming Cao ret2 = ext4_journal_stop(handle); 1337ac27a0ecSDave Kleikamp if (!ret) 1338ac27a0ecSDave Kleikamp ret = ret2; 1339bfc1af65SNick Piggin 1340f8514083SAneesh Kumar K.V if (pos + len > inode->i_size) { 1341b9a4207dSJan Kara ext4_truncate_failed_write(inode); 1342f8514083SAneesh Kumar K.V /* 1343ffacfa7aSJan Kara * If truncate failed early the inode might still be 1344f8514083SAneesh Kumar K.V * on the orphan list; we need to make sure the inode 1345f8514083SAneesh Kumar K.V * is removed from the orphan list in that case. 1346f8514083SAneesh Kumar K.V */ 1347f8514083SAneesh Kumar K.V if (inode->i_nlink) 1348f8514083SAneesh Kumar K.V ext4_orphan_del(NULL, inode); 1349f8514083SAneesh Kumar K.V } 1350f8514083SAneesh Kumar K.V 1351bfc1af65SNick Piggin return ret ? ret : copied; 1352ac27a0ecSDave Kleikamp } 1353ac27a0ecSDave Kleikamp 1354b90197b6STheodore Ts'o /* 1355b90197b6STheodore Ts'o * This is a private version of page_zero_new_buffers() which doesn't 1356b90197b6STheodore Ts'o * set the buffer to be dirty, since in data=journalled mode we need 1357b90197b6STheodore Ts'o * to call ext4_handle_dirty_metadata() instead. 1358b90197b6STheodore Ts'o */ 1359b90197b6STheodore Ts'o static void zero_new_buffers(struct page *page, unsigned from, unsigned to) 1360b90197b6STheodore Ts'o { 1361b90197b6STheodore Ts'o unsigned int block_start = 0, block_end; 1362b90197b6STheodore Ts'o struct buffer_head *head, *bh; 1363b90197b6STheodore Ts'o 1364b90197b6STheodore Ts'o bh = head = page_buffers(page); 1365b90197b6STheodore Ts'o do { 1366b90197b6STheodore Ts'o block_end = block_start + bh->b_size; 1367b90197b6STheodore Ts'o if (buffer_new(bh)) { 1368b90197b6STheodore Ts'o if (block_end > from && block_start < to) { 1369b90197b6STheodore Ts'o if (!PageUptodate(page)) { 1370b90197b6STheodore Ts'o unsigned start, size; 1371b90197b6STheodore Ts'o 1372b90197b6STheodore Ts'o start = max(from, block_start); 1373b90197b6STheodore Ts'o size = min(to, block_end) - start; 1374b90197b6STheodore Ts'o 1375b90197b6STheodore Ts'o zero_user(page, start, size); 1376b90197b6STheodore Ts'o set_buffer_uptodate(bh); 1377b90197b6STheodore Ts'o } 1378b90197b6STheodore Ts'o clear_buffer_new(bh); 1379b90197b6STheodore Ts'o } 1380b90197b6STheodore Ts'o } 1381b90197b6STheodore Ts'o block_start = block_end; 1382b90197b6STheodore Ts'o bh = bh->b_this_page; 1383b90197b6STheodore Ts'o } while (bh != head); 1384b90197b6STheodore Ts'o } 1385b90197b6STheodore Ts'o 1386bfc1af65SNick Piggin static int ext4_journalled_write_end(struct file *file, 1387bfc1af65SNick Piggin struct address_space *mapping, 1388bfc1af65SNick Piggin loff_t pos, unsigned len, unsigned copied, 1389bfc1af65SNick Piggin struct page *page, void *fsdata) 1390ac27a0ecSDave Kleikamp { 1391617ba13bSMingming Cao handle_t *handle = ext4_journal_current_handle(); 1392bfc1af65SNick Piggin struct inode *inode = mapping->host; 13930572639fSXiaoguang Wang loff_t old_size = inode->i_size; 1394ac27a0ecSDave Kleikamp int ret = 0, ret2; 1395ac27a0ecSDave Kleikamp int partial = 0; 1396bfc1af65SNick Piggin unsigned from, to; 13974631dbf6SDmitry Monakhov int size_changed = 0; 1398ac27a0ecSDave Kleikamp 13999bffad1eSTheodore Ts'o trace_ext4_journalled_write_end(inode, pos, len, copied); 1400bfc1af65SNick Piggin from = pos & (PAGE_CACHE_SIZE - 1); 1401bfc1af65SNick Piggin to = from + len; 1402bfc1af65SNick Piggin 1403441c8508SCurt Wohlgemuth BUG_ON(!ext4_handle_valid(handle)); 1404441c8508SCurt Wohlgemuth 14053fdcfb66STao Ma if (ext4_has_inline_data(inode)) 14063fdcfb66STao Ma copied = ext4_write_inline_data_end(inode, pos, len, 14073fdcfb66STao Ma copied, page); 14083fdcfb66STao Ma else { 1409bfc1af65SNick Piggin if (copied < len) { 1410bfc1af65SNick Piggin if (!PageUptodate(page)) 1411bfc1af65SNick Piggin copied = 0; 1412b90197b6STheodore Ts'o zero_new_buffers(page, from+copied, to); 1413bfc1af65SNick Piggin } 1414ac27a0ecSDave Kleikamp 1415f19d5870STao Ma ret = ext4_walk_page_buffers(handle, page_buffers(page), from, 1416bfc1af65SNick Piggin to, &partial, write_end_fn); 1417ac27a0ecSDave Kleikamp if (!partial) 1418ac27a0ecSDave Kleikamp SetPageUptodate(page); 14193fdcfb66STao Ma } 14204631dbf6SDmitry Monakhov size_changed = ext4_update_inode_size(inode, pos + copied); 142119f5fb7aSTheodore Ts'o ext4_set_inode_state(inode, EXT4_STATE_JDATA); 14222d859db3SJan Kara EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid; 14234631dbf6SDmitry Monakhov unlock_page(page); 14244631dbf6SDmitry Monakhov page_cache_release(page); 14254631dbf6SDmitry Monakhov 14260572639fSXiaoguang Wang if (old_size < pos) 14270572639fSXiaoguang Wang pagecache_isize_extended(inode, old_size, pos); 14280572639fSXiaoguang Wang 14294631dbf6SDmitry Monakhov if (size_changed) { 1430617ba13bSMingming Cao ret2 = ext4_mark_inode_dirty(handle, inode); 1431ac27a0ecSDave Kleikamp if (!ret) 1432ac27a0ecSDave Kleikamp ret = ret2; 1433ac27a0ecSDave Kleikamp } 1434bfc1af65SNick Piggin 1435ffacfa7aSJan Kara if (pos + len > inode->i_size && ext4_can_truncate(inode)) 1436f8514083SAneesh Kumar K.V /* if we have allocated more blocks and copied 1437f8514083SAneesh Kumar K.V * less. We will have blocks allocated outside 1438f8514083SAneesh Kumar K.V * inode->i_size. So truncate them 1439f8514083SAneesh Kumar K.V */ 1440f8514083SAneesh Kumar K.V ext4_orphan_add(handle, inode); 1441f8514083SAneesh Kumar K.V 1442617ba13bSMingming Cao ret2 = ext4_journal_stop(handle); 1443ac27a0ecSDave Kleikamp if (!ret) 1444ac27a0ecSDave Kleikamp ret = ret2; 1445f8514083SAneesh Kumar K.V if (pos + len > inode->i_size) { 1446b9a4207dSJan Kara ext4_truncate_failed_write(inode); 1447f8514083SAneesh Kumar K.V /* 1448ffacfa7aSJan Kara * If truncate failed early the inode might still be 1449f8514083SAneesh Kumar K.V * on the orphan list; we need to make sure the inode 1450f8514083SAneesh Kumar K.V * is removed from the orphan list in that case. 1451f8514083SAneesh Kumar K.V */ 1452f8514083SAneesh Kumar K.V if (inode->i_nlink) 1453f8514083SAneesh Kumar K.V ext4_orphan_del(NULL, inode); 1454f8514083SAneesh Kumar K.V } 1455bfc1af65SNick Piggin 1456bfc1af65SNick Piggin return ret ? ret : copied; 1457ac27a0ecSDave Kleikamp } 1458d2a17637SMingming Cao 14599d0be502STheodore Ts'o /* 1460c27e43a1SEric Whitney * Reserve space for a single cluster 14619d0be502STheodore Ts'o */ 1462c27e43a1SEric Whitney static int ext4_da_reserve_space(struct inode *inode) 1463d2a17637SMingming Cao { 1464d2a17637SMingming Cao struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 14650637c6f4STheodore Ts'o struct ext4_inode_info *ei = EXT4_I(inode); 14665dd4056dSChristoph Hellwig int ret; 1467d2a17637SMingming Cao 146860e58e0fSMingming Cao /* 146972b8ab9dSEric Sandeen * We will charge metadata quota at writeout time; this saves 147072b8ab9dSEric Sandeen * us from metadata over-estimation, though we may go over by 147172b8ab9dSEric Sandeen * a small amount in the end. Here we just reserve for data. 147260e58e0fSMingming Cao */ 14737b415bf6SAditya Kali ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1)); 14745dd4056dSChristoph Hellwig if (ret) 14755dd4056dSChristoph Hellwig return ret; 147603179fe9STheodore Ts'o 147703179fe9STheodore Ts'o spin_lock(&ei->i_block_reservation_lock); 147871d4f7d0STheodore Ts'o if (ext4_claim_free_clusters(sbi, 1, 0)) { 147903179fe9STheodore Ts'o spin_unlock(&ei->i_block_reservation_lock); 148003179fe9STheodore Ts'o dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1)); 1481d2a17637SMingming Cao return -ENOSPC; 1482d2a17637SMingming Cao } 14839d0be502STheodore Ts'o ei->i_reserved_data_blocks++; 1484c27e43a1SEric Whitney trace_ext4_da_reserve_space(inode); 14850637c6f4STheodore Ts'o spin_unlock(&ei->i_block_reservation_lock); 148639bc680aSDmitry Monakhov 1487d2a17637SMingming Cao return 0; /* success */ 1488d2a17637SMingming Cao } 1489d2a17637SMingming Cao 149012219aeaSAneesh Kumar K.V static void ext4_da_release_space(struct inode *inode, int to_free) 1491d2a17637SMingming Cao { 1492d2a17637SMingming Cao struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 14930637c6f4STheodore Ts'o struct ext4_inode_info *ei = EXT4_I(inode); 1494d2a17637SMingming Cao 1495cd213226SMingming Cao if (!to_free) 1496cd213226SMingming Cao return; /* Nothing to release, exit */ 1497cd213226SMingming Cao 1498d2a17637SMingming Cao spin_lock(&EXT4_I(inode)->i_block_reservation_lock); 1499cd213226SMingming Cao 15005a58ec87SLi Zefan trace_ext4_da_release_space(inode, to_free); 15010637c6f4STheodore Ts'o if (unlikely(to_free > ei->i_reserved_data_blocks)) { 1502cd213226SMingming Cao /* 15030637c6f4STheodore Ts'o * if there aren't enough reserved blocks, then the 15040637c6f4STheodore Ts'o * counter is messed up somewhere. Since this 15050637c6f4STheodore Ts'o * function is called from invalidate page, it's 15060637c6f4STheodore Ts'o * harmless to return without any action. 1507cd213226SMingming Cao */ 15088de5c325STheodore Ts'o ext4_warning(inode->i_sb, "ext4_da_release_space: " 15090637c6f4STheodore Ts'o "ino %lu, to_free %d with only %d reserved " 15101084f252STheodore Ts'o "data blocks", inode->i_ino, to_free, 15110637c6f4STheodore Ts'o ei->i_reserved_data_blocks); 15120637c6f4STheodore Ts'o WARN_ON(1); 15130637c6f4STheodore Ts'o to_free = ei->i_reserved_data_blocks; 15140637c6f4STheodore Ts'o } 15150637c6f4STheodore Ts'o ei->i_reserved_data_blocks -= to_free; 15160637c6f4STheodore Ts'o 151772b8ab9dSEric Sandeen /* update fs dirty data blocks counter */ 151857042651STheodore Ts'o percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free); 1519d2a17637SMingming Cao 1520d2a17637SMingming Cao spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 152160e58e0fSMingming Cao 15227b415bf6SAditya Kali dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free)); 1523d2a17637SMingming Cao } 1524d2a17637SMingming Cao 1525d2a17637SMingming Cao static void ext4_da_page_release_reservation(struct page *page, 1526ca99fdd2SLukas Czerner unsigned int offset, 1527ca99fdd2SLukas Czerner unsigned int length) 1528d2a17637SMingming Cao { 15299705acd6SLukas Czerner int to_release = 0, contiguous_blks = 0; 1530d2a17637SMingming Cao struct buffer_head *head, *bh; 1531d2a17637SMingming Cao unsigned int curr_off = 0; 15327b415bf6SAditya Kali struct inode *inode = page->mapping->host; 15337b415bf6SAditya Kali struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 1534ca99fdd2SLukas Czerner unsigned int stop = offset + length; 15357b415bf6SAditya Kali int num_clusters; 153651865fdaSZheng Liu ext4_fsblk_t lblk; 1537d2a17637SMingming Cao 1538ca99fdd2SLukas Czerner BUG_ON(stop > PAGE_CACHE_SIZE || stop < length); 1539ca99fdd2SLukas Czerner 1540d2a17637SMingming Cao head = page_buffers(page); 1541d2a17637SMingming Cao bh = head; 1542d2a17637SMingming Cao do { 1543d2a17637SMingming Cao unsigned int next_off = curr_off + bh->b_size; 1544d2a17637SMingming Cao 1545ca99fdd2SLukas Czerner if (next_off > stop) 1546ca99fdd2SLukas Czerner break; 1547ca99fdd2SLukas Czerner 1548d2a17637SMingming Cao if ((offset <= curr_off) && (buffer_delay(bh))) { 1549d2a17637SMingming Cao to_release++; 15509705acd6SLukas Czerner contiguous_blks++; 1551d2a17637SMingming Cao clear_buffer_delay(bh); 15529705acd6SLukas Czerner } else if (contiguous_blks) { 15539705acd6SLukas Czerner lblk = page->index << 15549705acd6SLukas Czerner (PAGE_CACHE_SHIFT - inode->i_blkbits); 15559705acd6SLukas Czerner lblk += (curr_off >> inode->i_blkbits) - 15569705acd6SLukas Czerner contiguous_blks; 15579705acd6SLukas Czerner ext4_es_remove_extent(inode, lblk, contiguous_blks); 15589705acd6SLukas Czerner contiguous_blks = 0; 1559d2a17637SMingming Cao } 1560d2a17637SMingming Cao curr_off = next_off; 1561d2a17637SMingming Cao } while ((bh = bh->b_this_page) != head); 15627b415bf6SAditya Kali 15639705acd6SLukas Czerner if (contiguous_blks) { 156451865fdaSZheng Liu lblk = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits); 15659705acd6SLukas Czerner lblk += (curr_off >> inode->i_blkbits) - contiguous_blks; 15669705acd6SLukas Czerner ext4_es_remove_extent(inode, lblk, contiguous_blks); 156751865fdaSZheng Liu } 156851865fdaSZheng Liu 15697b415bf6SAditya Kali /* If we have released all the blocks belonging to a cluster, then we 15707b415bf6SAditya Kali * need to release the reserved space for that cluster. */ 15717b415bf6SAditya Kali num_clusters = EXT4_NUM_B2C(sbi, to_release); 15727b415bf6SAditya Kali while (num_clusters > 0) { 15737b415bf6SAditya Kali lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) + 15747b415bf6SAditya Kali ((num_clusters - 1) << sbi->s_cluster_bits); 15757b415bf6SAditya Kali if (sbi->s_cluster_ratio == 1 || 15767d1b1fbcSZheng Liu !ext4_find_delalloc_cluster(inode, lblk)) 15777b415bf6SAditya Kali ext4_da_release_space(inode, 1); 15787b415bf6SAditya Kali 15797b415bf6SAditya Kali num_clusters--; 15807b415bf6SAditya Kali } 1581d2a17637SMingming Cao } 1582ac27a0ecSDave Kleikamp 1583ac27a0ecSDave Kleikamp /* 158464769240SAlex Tomas * Delayed allocation stuff 158564769240SAlex Tomas */ 158664769240SAlex Tomas 15874e7ea81dSJan Kara struct mpage_da_data { 15884e7ea81dSJan Kara struct inode *inode; 15894e7ea81dSJan Kara struct writeback_control *wbc; 15906b523df4SJan Kara 15914e7ea81dSJan Kara pgoff_t first_page; /* The first page to write */ 15924e7ea81dSJan Kara pgoff_t next_page; /* Current page to examine */ 15934e7ea81dSJan Kara pgoff_t last_page; /* Last page to examine */ 159464769240SAlex Tomas /* 15954e7ea81dSJan Kara * Extent to map - this can be after first_page because that can be 15964e7ea81dSJan Kara * fully mapped. We somewhat abuse m_flags to store whether the extent 15974e7ea81dSJan Kara * is delalloc or unwritten. 159864769240SAlex Tomas */ 15994e7ea81dSJan Kara struct ext4_map_blocks map; 16004e7ea81dSJan Kara struct ext4_io_submit io_submit; /* IO submission data */ 16014e7ea81dSJan Kara }; 160264769240SAlex Tomas 16034e7ea81dSJan Kara static void mpage_release_unused_pages(struct mpage_da_data *mpd, 16044e7ea81dSJan Kara bool invalidate) 1605c4a0c46eSAneesh Kumar K.V { 1606c4a0c46eSAneesh Kumar K.V int nr_pages, i; 1607c4a0c46eSAneesh Kumar K.V pgoff_t index, end; 1608c4a0c46eSAneesh Kumar K.V struct pagevec pvec; 1609c4a0c46eSAneesh Kumar K.V struct inode *inode = mpd->inode; 1610c4a0c46eSAneesh Kumar K.V struct address_space *mapping = inode->i_mapping; 16114e7ea81dSJan Kara 16124e7ea81dSJan Kara /* This is necessary when next_page == 0. */ 16134e7ea81dSJan Kara if (mpd->first_page >= mpd->next_page) 16144e7ea81dSJan Kara return; 1615c4a0c46eSAneesh Kumar K.V 1616c7f5938aSCurt Wohlgemuth index = mpd->first_page; 1617c7f5938aSCurt Wohlgemuth end = mpd->next_page - 1; 16184e7ea81dSJan Kara if (invalidate) { 16194e7ea81dSJan Kara ext4_lblk_t start, last; 162051865fdaSZheng Liu start = index << (PAGE_CACHE_SHIFT - inode->i_blkbits); 162151865fdaSZheng Liu last = end << (PAGE_CACHE_SHIFT - inode->i_blkbits); 162251865fdaSZheng Liu ext4_es_remove_extent(inode, start, last - start + 1); 16234e7ea81dSJan Kara } 162451865fdaSZheng Liu 162566bea92cSEric Sandeen pagevec_init(&pvec, 0); 1626c4a0c46eSAneesh Kumar K.V while (index <= end) { 1627c4a0c46eSAneesh Kumar K.V nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE); 1628c4a0c46eSAneesh Kumar K.V if (nr_pages == 0) 1629c4a0c46eSAneesh Kumar K.V break; 1630c4a0c46eSAneesh Kumar K.V for (i = 0; i < nr_pages; i++) { 1631c4a0c46eSAneesh Kumar K.V struct page *page = pvec.pages[i]; 16329b1d0998SJan Kara if (page->index > end) 1633c4a0c46eSAneesh Kumar K.V break; 1634c4a0c46eSAneesh Kumar K.V BUG_ON(!PageLocked(page)); 1635c4a0c46eSAneesh Kumar K.V BUG_ON(PageWriteback(page)); 16364e7ea81dSJan Kara if (invalidate) { 1637d47992f8SLukas Czerner block_invalidatepage(page, 0, PAGE_CACHE_SIZE); 1638c4a0c46eSAneesh Kumar K.V ClearPageUptodate(page); 16394e7ea81dSJan Kara } 1640c4a0c46eSAneesh Kumar K.V unlock_page(page); 1641c4a0c46eSAneesh Kumar K.V } 16429b1d0998SJan Kara index = pvec.pages[nr_pages - 1]->index + 1; 16439b1d0998SJan Kara pagevec_release(&pvec); 1644c4a0c46eSAneesh Kumar K.V } 1645c4a0c46eSAneesh Kumar K.V } 1646c4a0c46eSAneesh Kumar K.V 1647df22291fSAneesh Kumar K.V static void ext4_print_free_blocks(struct inode *inode) 1648df22291fSAneesh Kumar K.V { 1649df22291fSAneesh Kumar K.V struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 165092b97816STheodore Ts'o struct super_block *sb = inode->i_sb; 1651f78ee70dSLukas Czerner struct ext4_inode_info *ei = EXT4_I(inode); 165292b97816STheodore Ts'o 165392b97816STheodore Ts'o ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld", 16545dee5437STheodore Ts'o EXT4_C2B(EXT4_SB(inode->i_sb), 1655f78ee70dSLukas Czerner ext4_count_free_clusters(sb))); 165692b97816STheodore Ts'o ext4_msg(sb, KERN_CRIT, "Free/Dirty block details"); 165792b97816STheodore Ts'o ext4_msg(sb, KERN_CRIT, "free_blocks=%lld", 1658f78ee70dSLukas Czerner (long long) EXT4_C2B(EXT4_SB(sb), 165957042651STheodore Ts'o percpu_counter_sum(&sbi->s_freeclusters_counter))); 166092b97816STheodore Ts'o ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld", 1661f78ee70dSLukas Czerner (long long) EXT4_C2B(EXT4_SB(sb), 16627b415bf6SAditya Kali percpu_counter_sum(&sbi->s_dirtyclusters_counter))); 166392b97816STheodore Ts'o ext4_msg(sb, KERN_CRIT, "Block reservation details"); 166492b97816STheodore Ts'o ext4_msg(sb, KERN_CRIT, "i_reserved_data_blocks=%u", 1665f78ee70dSLukas Czerner ei->i_reserved_data_blocks); 1666df22291fSAneesh Kumar K.V return; 1667df22291fSAneesh Kumar K.V } 1668df22291fSAneesh Kumar K.V 1669c364b22cSAneesh Kumar K.V static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh) 167029fa89d0SAneesh Kumar K.V { 1671c364b22cSAneesh Kumar K.V return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh); 167229fa89d0SAneesh Kumar K.V } 167329fa89d0SAneesh Kumar K.V 167464769240SAlex Tomas /* 16755356f261SAditya Kali * This function is grabs code from the very beginning of 16765356f261SAditya Kali * ext4_map_blocks, but assumes that the caller is from delayed write 16775356f261SAditya Kali * time. This function looks up the requested blocks and sets the 16785356f261SAditya Kali * buffer delay bit under the protection of i_data_sem. 16795356f261SAditya Kali */ 16805356f261SAditya Kali static int ext4_da_map_blocks(struct inode *inode, sector_t iblock, 16815356f261SAditya Kali struct ext4_map_blocks *map, 16825356f261SAditya Kali struct buffer_head *bh) 16835356f261SAditya Kali { 1684d100eef2SZheng Liu struct extent_status es; 16855356f261SAditya Kali int retval; 16865356f261SAditya Kali sector_t invalid_block = ~((sector_t) 0xffff); 1687921f266bSDmitry Monakhov #ifdef ES_AGGRESSIVE_TEST 1688921f266bSDmitry Monakhov struct ext4_map_blocks orig_map; 1689921f266bSDmitry Monakhov 1690921f266bSDmitry Monakhov memcpy(&orig_map, map, sizeof(*map)); 1691921f266bSDmitry Monakhov #endif 16925356f261SAditya Kali 16935356f261SAditya Kali if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es)) 16945356f261SAditya Kali invalid_block = ~0; 16955356f261SAditya Kali 16965356f261SAditya Kali map->m_flags = 0; 16975356f261SAditya Kali ext_debug("ext4_da_map_blocks(): inode %lu, max_blocks %u," 16985356f261SAditya Kali "logical block %lu\n", inode->i_ino, map->m_len, 16995356f261SAditya Kali (unsigned long) map->m_lblk); 1700d100eef2SZheng Liu 1701d100eef2SZheng Liu /* Lookup extent status tree firstly */ 1702d100eef2SZheng Liu if (ext4_es_lookup_extent(inode, iblock, &es)) { 1703d100eef2SZheng Liu if (ext4_es_is_hole(&es)) { 1704d100eef2SZheng Liu retval = 0; 1705c8b459f4SLukas Czerner down_read(&EXT4_I(inode)->i_data_sem); 1706d100eef2SZheng Liu goto add_delayed; 1707d100eef2SZheng Liu } 1708d100eef2SZheng Liu 1709d100eef2SZheng Liu /* 1710d100eef2SZheng Liu * Delayed extent could be allocated by fallocate. 1711d100eef2SZheng Liu * So we need to check it. 1712d100eef2SZheng Liu */ 1713d100eef2SZheng Liu if (ext4_es_is_delayed(&es) && !ext4_es_is_unwritten(&es)) { 1714d100eef2SZheng Liu map_bh(bh, inode->i_sb, invalid_block); 1715d100eef2SZheng Liu set_buffer_new(bh); 1716d100eef2SZheng Liu set_buffer_delay(bh); 1717d100eef2SZheng Liu return 0; 1718d100eef2SZheng Liu } 1719d100eef2SZheng Liu 1720d100eef2SZheng Liu map->m_pblk = ext4_es_pblock(&es) + iblock - es.es_lblk; 1721d100eef2SZheng Liu retval = es.es_len - (iblock - es.es_lblk); 1722d100eef2SZheng Liu if (retval > map->m_len) 1723d100eef2SZheng Liu retval = map->m_len; 1724d100eef2SZheng Liu map->m_len = retval; 1725d100eef2SZheng Liu if (ext4_es_is_written(&es)) 1726d100eef2SZheng Liu map->m_flags |= EXT4_MAP_MAPPED; 1727d100eef2SZheng Liu else if (ext4_es_is_unwritten(&es)) 1728d100eef2SZheng Liu map->m_flags |= EXT4_MAP_UNWRITTEN; 1729d100eef2SZheng Liu else 1730d100eef2SZheng Liu BUG_ON(1); 1731d100eef2SZheng Liu 1732921f266bSDmitry Monakhov #ifdef ES_AGGRESSIVE_TEST 1733921f266bSDmitry Monakhov ext4_map_blocks_es_recheck(NULL, inode, map, &orig_map, 0); 1734921f266bSDmitry Monakhov #endif 1735d100eef2SZheng Liu return retval; 1736d100eef2SZheng Liu } 1737d100eef2SZheng Liu 17385356f261SAditya Kali /* 17395356f261SAditya Kali * Try to see if we can get the block without requesting a new 17405356f261SAditya Kali * file system block. 17415356f261SAditya Kali */ 1742c8b459f4SLukas Czerner down_read(&EXT4_I(inode)->i_data_sem); 1743cbd7584eSJan Kara if (ext4_has_inline_data(inode)) 17449c3569b5STao Ma retval = 0; 1745cbd7584eSJan Kara else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) 17462f8e0a7cSZheng Liu retval = ext4_ext_map_blocks(NULL, inode, map, 0); 17475356f261SAditya Kali else 17482f8e0a7cSZheng Liu retval = ext4_ind_map_blocks(NULL, inode, map, 0); 17495356f261SAditya Kali 1750d100eef2SZheng Liu add_delayed: 17515356f261SAditya Kali if (retval == 0) { 1752f7fec032SZheng Liu int ret; 17535356f261SAditya Kali /* 17545356f261SAditya Kali * XXX: __block_prepare_write() unmaps passed block, 17555356f261SAditya Kali * is it OK? 17565356f261SAditya Kali */ 1757386ad67cSLukas Czerner /* 1758386ad67cSLukas Czerner * If the block was allocated from previously allocated cluster, 1759386ad67cSLukas Czerner * then we don't need to reserve it again. However we still need 1760386ad67cSLukas Czerner * to reserve metadata for every block we're going to write. 1761386ad67cSLukas Czerner */ 1762c27e43a1SEric Whitney if (EXT4_SB(inode->i_sb)->s_cluster_ratio == 1 || 1763cbd7584eSJan Kara !ext4_find_delalloc_cluster(inode, map->m_lblk)) { 1764c27e43a1SEric Whitney ret = ext4_da_reserve_space(inode); 1765f7fec032SZheng Liu if (ret) { 17665356f261SAditya Kali /* not enough space to reserve */ 1767f7fec032SZheng Liu retval = ret; 17685356f261SAditya Kali goto out_unlock; 17695356f261SAditya Kali } 1770f7fec032SZheng Liu } 17715356f261SAditya Kali 1772f7fec032SZheng Liu ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len, 1773fdc0212eSZheng Liu ~0, EXTENT_STATUS_DELAYED); 1774f7fec032SZheng Liu if (ret) { 1775f7fec032SZheng Liu retval = ret; 177651865fdaSZheng Liu goto out_unlock; 1777f7fec032SZheng Liu } 177851865fdaSZheng Liu 17795356f261SAditya Kali map_bh(bh, inode->i_sb, invalid_block); 17805356f261SAditya Kali set_buffer_new(bh); 17815356f261SAditya Kali set_buffer_delay(bh); 1782f7fec032SZheng Liu } else if (retval > 0) { 1783f7fec032SZheng Liu int ret; 17843be78c73STheodore Ts'o unsigned int status; 1785f7fec032SZheng Liu 178644fb851dSZheng Liu if (unlikely(retval != map->m_len)) { 178744fb851dSZheng Liu ext4_warning(inode->i_sb, 178844fb851dSZheng Liu "ES len assertion failed for inode " 178944fb851dSZheng Liu "%lu: retval %d != map->m_len %d", 179044fb851dSZheng Liu inode->i_ino, retval, map->m_len); 179144fb851dSZheng Liu WARN_ON(1); 1792921f266bSDmitry Monakhov } 1793921f266bSDmitry Monakhov 1794f7fec032SZheng Liu status = map->m_flags & EXT4_MAP_UNWRITTEN ? 1795f7fec032SZheng Liu EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN; 1796f7fec032SZheng Liu ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len, 1797f7fec032SZheng Liu map->m_pblk, status); 1798f7fec032SZheng Liu if (ret != 0) 1799f7fec032SZheng Liu retval = ret; 18005356f261SAditya Kali } 18015356f261SAditya Kali 18025356f261SAditya Kali out_unlock: 18035356f261SAditya Kali up_read((&EXT4_I(inode)->i_data_sem)); 18045356f261SAditya Kali 18055356f261SAditya Kali return retval; 18065356f261SAditya Kali } 18075356f261SAditya Kali 18085356f261SAditya Kali /* 1809d91bd2c1SSeunghun Lee * This is a special get_block_t callback which is used by 1810b920c755STheodore Ts'o * ext4_da_write_begin(). It will either return mapped block or 1811b920c755STheodore Ts'o * reserve space for a single block. 181229fa89d0SAneesh Kumar K.V * 181329fa89d0SAneesh Kumar K.V * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set. 181429fa89d0SAneesh Kumar K.V * We also have b_blocknr = -1 and b_bdev initialized properly 181529fa89d0SAneesh Kumar K.V * 181629fa89d0SAneesh Kumar K.V * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set. 181729fa89d0SAneesh Kumar K.V * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev 181829fa89d0SAneesh Kumar K.V * initialized properly. 181964769240SAlex Tomas */ 18209c3569b5STao Ma int ext4_da_get_block_prep(struct inode *inode, sector_t iblock, 18212ed88685STheodore Ts'o struct buffer_head *bh, int create) 182264769240SAlex Tomas { 18232ed88685STheodore Ts'o struct ext4_map_blocks map; 182464769240SAlex Tomas int ret = 0; 182564769240SAlex Tomas 182664769240SAlex Tomas BUG_ON(create == 0); 18272ed88685STheodore Ts'o BUG_ON(bh->b_size != inode->i_sb->s_blocksize); 18282ed88685STheodore Ts'o 18292ed88685STheodore Ts'o map.m_lblk = iblock; 18302ed88685STheodore Ts'o map.m_len = 1; 183164769240SAlex Tomas 183264769240SAlex Tomas /* 183364769240SAlex Tomas * first, we need to know whether the block is allocated already 183464769240SAlex Tomas * preallocated blocks are unmapped but should treated 183564769240SAlex Tomas * the same as allocated blocks. 183664769240SAlex Tomas */ 18375356f261SAditya Kali ret = ext4_da_map_blocks(inode, iblock, &map, bh); 18385356f261SAditya Kali if (ret <= 0) 18392ed88685STheodore Ts'o return ret; 184064769240SAlex Tomas 18412ed88685STheodore Ts'o map_bh(bh, inode->i_sb, map.m_pblk); 1842ed8ad838SJan Kara ext4_update_bh_state(bh, map.m_flags); 18432ed88685STheodore Ts'o 18442ed88685STheodore Ts'o if (buffer_unwritten(bh)) { 18452ed88685STheodore Ts'o /* A delayed write to unwritten bh should be marked 18462ed88685STheodore Ts'o * new and mapped. Mapped ensures that we don't do 18472ed88685STheodore Ts'o * get_block multiple times when we write to the same 18482ed88685STheodore Ts'o * offset and new ensures that we do proper zero out 18492ed88685STheodore Ts'o * for partial write. 18502ed88685STheodore Ts'o */ 18512ed88685STheodore Ts'o set_buffer_new(bh); 1852c8205636STheodore Ts'o set_buffer_mapped(bh); 18532ed88685STheodore Ts'o } 18542ed88685STheodore Ts'o return 0; 185564769240SAlex Tomas } 185661628a3fSMingming Cao 185762e086beSAneesh Kumar K.V static int bget_one(handle_t *handle, struct buffer_head *bh) 185862e086beSAneesh Kumar K.V { 185962e086beSAneesh Kumar K.V get_bh(bh); 186062e086beSAneesh Kumar K.V return 0; 186162e086beSAneesh Kumar K.V } 186262e086beSAneesh Kumar K.V 186362e086beSAneesh Kumar K.V static int bput_one(handle_t *handle, struct buffer_head *bh) 186462e086beSAneesh Kumar K.V { 186562e086beSAneesh Kumar K.V put_bh(bh); 186662e086beSAneesh Kumar K.V return 0; 186762e086beSAneesh Kumar K.V } 186862e086beSAneesh Kumar K.V 186962e086beSAneesh Kumar K.V static int __ext4_journalled_writepage(struct page *page, 187062e086beSAneesh Kumar K.V unsigned int len) 187162e086beSAneesh Kumar K.V { 187262e086beSAneesh Kumar K.V struct address_space *mapping = page->mapping; 187362e086beSAneesh Kumar K.V struct inode *inode = mapping->host; 18743fdcfb66STao Ma struct buffer_head *page_bufs = NULL; 187562e086beSAneesh Kumar K.V handle_t *handle = NULL; 18763fdcfb66STao Ma int ret = 0, err = 0; 18773fdcfb66STao Ma int inline_data = ext4_has_inline_data(inode); 18783fdcfb66STao Ma struct buffer_head *inode_bh = NULL; 187962e086beSAneesh Kumar K.V 1880cb20d518STheodore Ts'o ClearPageChecked(page); 18813fdcfb66STao Ma 18823fdcfb66STao Ma if (inline_data) { 18833fdcfb66STao Ma BUG_ON(page->index != 0); 18843fdcfb66STao Ma BUG_ON(len > ext4_get_max_inline_size(inode)); 18853fdcfb66STao Ma inode_bh = ext4_journalled_write_inline_data(inode, len, page); 18863fdcfb66STao Ma if (inode_bh == NULL) 18873fdcfb66STao Ma goto out; 18883fdcfb66STao Ma } else { 188962e086beSAneesh Kumar K.V page_bufs = page_buffers(page); 18903fdcfb66STao Ma if (!page_bufs) { 18913fdcfb66STao Ma BUG(); 18923fdcfb66STao Ma goto out; 18933fdcfb66STao Ma } 18943fdcfb66STao Ma ext4_walk_page_buffers(handle, page_bufs, 0, len, 18953fdcfb66STao Ma NULL, bget_one); 18963fdcfb66STao Ma } 1897bdf96838STheodore Ts'o /* 1898bdf96838STheodore Ts'o * We need to release the page lock before we start the 1899bdf96838STheodore Ts'o * journal, so grab a reference so the page won't disappear 1900bdf96838STheodore Ts'o * out from under us. 1901bdf96838STheodore Ts'o */ 1902bdf96838STheodore Ts'o get_page(page); 190362e086beSAneesh Kumar K.V unlock_page(page); 190462e086beSAneesh Kumar K.V 19059924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 19069924a92aSTheodore Ts'o ext4_writepage_trans_blocks(inode)); 190762e086beSAneesh Kumar K.V if (IS_ERR(handle)) { 190862e086beSAneesh Kumar K.V ret = PTR_ERR(handle); 1909bdf96838STheodore Ts'o put_page(page); 1910bdf96838STheodore Ts'o goto out_no_pagelock; 1911bdf96838STheodore Ts'o } 1912bdf96838STheodore Ts'o BUG_ON(!ext4_handle_valid(handle)); 1913bdf96838STheodore Ts'o 1914bdf96838STheodore Ts'o lock_page(page); 1915bdf96838STheodore Ts'o put_page(page); 1916bdf96838STheodore Ts'o if (page->mapping != mapping) { 1917bdf96838STheodore Ts'o /* The page got truncated from under us */ 1918bdf96838STheodore Ts'o ext4_journal_stop(handle); 1919bdf96838STheodore Ts'o ret = 0; 192062e086beSAneesh Kumar K.V goto out; 192162e086beSAneesh Kumar K.V } 192262e086beSAneesh Kumar K.V 19233fdcfb66STao Ma if (inline_data) { 19245d601255Sliang xie BUFFER_TRACE(inode_bh, "get write access"); 19253fdcfb66STao Ma ret = ext4_journal_get_write_access(handle, inode_bh); 19263fdcfb66STao Ma 19273fdcfb66STao Ma err = ext4_handle_dirty_metadata(handle, inode, inode_bh); 19283fdcfb66STao Ma 19293fdcfb66STao Ma } else { 1930f19d5870STao Ma ret = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL, 193162e086beSAneesh Kumar K.V do_journal_get_write_access); 193262e086beSAneesh Kumar K.V 1933f19d5870STao Ma err = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL, 193462e086beSAneesh Kumar K.V write_end_fn); 19353fdcfb66STao Ma } 193662e086beSAneesh Kumar K.V if (ret == 0) 193762e086beSAneesh Kumar K.V ret = err; 19382d859db3SJan Kara EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid; 193962e086beSAneesh Kumar K.V err = ext4_journal_stop(handle); 194062e086beSAneesh Kumar K.V if (!ret) 194162e086beSAneesh Kumar K.V ret = err; 194262e086beSAneesh Kumar K.V 19433fdcfb66STao Ma if (!ext4_has_inline_data(inode)) 19448c9367fdSTheodore Ts'o ext4_walk_page_buffers(NULL, page_bufs, 0, len, 19453fdcfb66STao Ma NULL, bput_one); 194619f5fb7aSTheodore Ts'o ext4_set_inode_state(inode, EXT4_STATE_JDATA); 194762e086beSAneesh Kumar K.V out: 1948bdf96838STheodore Ts'o unlock_page(page); 1949bdf96838STheodore Ts'o out_no_pagelock: 19503fdcfb66STao Ma brelse(inode_bh); 195162e086beSAneesh Kumar K.V return ret; 195262e086beSAneesh Kumar K.V } 195362e086beSAneesh Kumar K.V 195461628a3fSMingming Cao /* 195543ce1d23SAneesh Kumar K.V * Note that we don't need to start a transaction unless we're journaling data 195643ce1d23SAneesh Kumar K.V * because we should have holes filled from ext4_page_mkwrite(). We even don't 195743ce1d23SAneesh Kumar K.V * need to file the inode to the transaction's list in ordered mode because if 195843ce1d23SAneesh Kumar K.V * we are writing back data added by write(), the inode is already there and if 195943ce1d23SAneesh Kumar K.V * we are writing back data modified via mmap(), no one guarantees in which 196043ce1d23SAneesh Kumar K.V * transaction the data will hit the disk. In case we are journaling data, we 196143ce1d23SAneesh Kumar K.V * cannot start transaction directly because transaction start ranks above page 196243ce1d23SAneesh Kumar K.V * lock so we have to do some magic. 196343ce1d23SAneesh Kumar K.V * 1964b920c755STheodore Ts'o * This function can get called via... 196520970ba6STheodore Ts'o * - ext4_writepages after taking page lock (have journal handle) 1966b920c755STheodore Ts'o * - journal_submit_inode_data_buffers (no journal handle) 1967f6463b0dSArtem Bityutskiy * - shrink_page_list via the kswapd/direct reclaim (no journal handle) 1968b920c755STheodore Ts'o * - grab_page_cache when doing write_begin (have journal handle) 196943ce1d23SAneesh Kumar K.V * 197043ce1d23SAneesh Kumar K.V * We don't do any block allocation in this function. If we have page with 197143ce1d23SAneesh Kumar K.V * multiple blocks we need to write those buffer_heads that are mapped. This 197243ce1d23SAneesh Kumar K.V * is important for mmaped based write. So if we do with blocksize 1K 197343ce1d23SAneesh Kumar K.V * truncate(f, 1024); 197443ce1d23SAneesh Kumar K.V * a = mmap(f, 0, 4096); 197543ce1d23SAneesh Kumar K.V * a[0] = 'a'; 197643ce1d23SAneesh Kumar K.V * truncate(f, 4096); 197743ce1d23SAneesh Kumar K.V * we have in the page first buffer_head mapped via page_mkwrite call back 197890802ed9SPaul Bolle * but other buffer_heads would be unmapped but dirty (dirty done via the 197943ce1d23SAneesh Kumar K.V * do_wp_page). So writepage should write the first block. If we modify 198043ce1d23SAneesh Kumar K.V * the mmap area beyond 1024 we will again get a page_fault and the 198143ce1d23SAneesh Kumar K.V * page_mkwrite callback will do the block allocation and mark the 198243ce1d23SAneesh Kumar K.V * buffer_heads mapped. 198343ce1d23SAneesh Kumar K.V * 198443ce1d23SAneesh Kumar K.V * We redirty the page if we have any buffer_heads that is either delay or 198543ce1d23SAneesh Kumar K.V * unwritten in the page. 198643ce1d23SAneesh Kumar K.V * 198743ce1d23SAneesh Kumar K.V * We can get recursively called as show below. 198843ce1d23SAneesh Kumar K.V * 198943ce1d23SAneesh Kumar K.V * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() -> 199043ce1d23SAneesh Kumar K.V * ext4_writepage() 199143ce1d23SAneesh Kumar K.V * 199243ce1d23SAneesh Kumar K.V * But since we don't do any block allocation we should not deadlock. 199343ce1d23SAneesh Kumar K.V * Page also have the dirty flag cleared so we don't get recurive page_lock. 199461628a3fSMingming Cao */ 199543ce1d23SAneesh Kumar K.V static int ext4_writepage(struct page *page, 199664769240SAlex Tomas struct writeback_control *wbc) 199764769240SAlex Tomas { 1998f8bec370SJan Kara int ret = 0; 199961628a3fSMingming Cao loff_t size; 2000498e5f24STheodore Ts'o unsigned int len; 2001744692dcSJiaying Zhang struct buffer_head *page_bufs = NULL; 200261628a3fSMingming Cao struct inode *inode = page->mapping->host; 200336ade451SJan Kara struct ext4_io_submit io_submit; 20041c8349a1SNamjae Jeon bool keep_towrite = false; 200564769240SAlex Tomas 2006a9c667f8SLukas Czerner trace_ext4_writepage(page); 200761628a3fSMingming Cao size = i_size_read(inode); 200861628a3fSMingming Cao if (page->index == size >> PAGE_CACHE_SHIFT) 200961628a3fSMingming Cao len = size & ~PAGE_CACHE_MASK; 201061628a3fSMingming Cao else 201161628a3fSMingming Cao len = PAGE_CACHE_SIZE; 201261628a3fSMingming Cao 2013f0e6c985SAneesh Kumar K.V page_bufs = page_buffers(page); 201464769240SAlex Tomas /* 2015fe386132SJan Kara * We cannot do block allocation or other extent handling in this 2016fe386132SJan Kara * function. If there are buffers needing that, we have to redirty 2017fe386132SJan Kara * the page. But we may reach here when we do a journal commit via 2018fe386132SJan Kara * journal_submit_inode_data_buffers() and in that case we must write 2019fe386132SJan Kara * allocated buffers to achieve data=ordered mode guarantees. 2020cccd147aSTheodore Ts'o * 2021cccd147aSTheodore Ts'o * Also, if there is only one buffer per page (the fs block 2022cccd147aSTheodore Ts'o * size == the page size), if one buffer needs block 2023cccd147aSTheodore Ts'o * allocation or needs to modify the extent tree to clear the 2024cccd147aSTheodore Ts'o * unwritten flag, we know that the page can't be written at 2025cccd147aSTheodore Ts'o * all, so we might as well refuse the write immediately. 2026cccd147aSTheodore Ts'o * Unfortunately if the block size != page size, we can't as 2027cccd147aSTheodore Ts'o * easily detect this case using ext4_walk_page_buffers(), but 2028cccd147aSTheodore Ts'o * for the extremely common case, this is an optimization that 2029cccd147aSTheodore Ts'o * skips a useless round trip through ext4_bio_write_page(). 203064769240SAlex Tomas */ 2031f19d5870STao Ma if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL, 2032c364b22cSAneesh Kumar K.V ext4_bh_delay_or_unwritten)) { 203361628a3fSMingming Cao redirty_page_for_writepage(wbc, page); 2034cccd147aSTheodore Ts'o if ((current->flags & PF_MEMALLOC) || 2035cccd147aSTheodore Ts'o (inode->i_sb->s_blocksize == PAGE_CACHE_SIZE)) { 2036fe386132SJan Kara /* 2037fe386132SJan Kara * For memory cleaning there's no point in writing only 2038fe386132SJan Kara * some buffers. So just bail out. Warn if we came here 2039fe386132SJan Kara * from direct reclaim. 2040fe386132SJan Kara */ 2041fe386132SJan Kara WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) 2042fe386132SJan Kara == PF_MEMALLOC); 204361628a3fSMingming Cao unlock_page(page); 204461628a3fSMingming Cao return 0; 204561628a3fSMingming Cao } 20461c8349a1SNamjae Jeon keep_towrite = true; 2047f0e6c985SAneesh Kumar K.V } 204864769240SAlex Tomas 2049cb20d518STheodore Ts'o if (PageChecked(page) && ext4_should_journal_data(inode)) 205043ce1d23SAneesh Kumar K.V /* 205143ce1d23SAneesh Kumar K.V * It's mmapped pagecache. Add buffers and journal it. There 205243ce1d23SAneesh Kumar K.V * doesn't seem much point in redirtying the page here. 205343ce1d23SAneesh Kumar K.V */ 20543f0ca309SWu Fengguang return __ext4_journalled_writepage(page, len); 205543ce1d23SAneesh Kumar K.V 205697a851edSJan Kara ext4_io_submit_init(&io_submit, wbc); 205797a851edSJan Kara io_submit.io_end = ext4_init_io_end(inode, GFP_NOFS); 205897a851edSJan Kara if (!io_submit.io_end) { 205997a851edSJan Kara redirty_page_for_writepage(wbc, page); 206097a851edSJan Kara unlock_page(page); 206197a851edSJan Kara return -ENOMEM; 206297a851edSJan Kara } 20631c8349a1SNamjae Jeon ret = ext4_bio_write_page(&io_submit, page, len, wbc, keep_towrite); 206436ade451SJan Kara ext4_io_submit(&io_submit); 206597a851edSJan Kara /* Drop io_end reference we got from init */ 206697a851edSJan Kara ext4_put_io_end_defer(io_submit.io_end); 206764769240SAlex Tomas return ret; 206864769240SAlex Tomas } 206964769240SAlex Tomas 20705f1132b2SJan Kara static int mpage_submit_page(struct mpage_da_data *mpd, struct page *page) 20715f1132b2SJan Kara { 20725f1132b2SJan Kara int len; 20735f1132b2SJan Kara loff_t size = i_size_read(mpd->inode); 20745f1132b2SJan Kara int err; 20755f1132b2SJan Kara 20765f1132b2SJan Kara BUG_ON(page->index != mpd->first_page); 20775f1132b2SJan Kara if (page->index == size >> PAGE_CACHE_SHIFT) 20785f1132b2SJan Kara len = size & ~PAGE_CACHE_MASK; 20795f1132b2SJan Kara else 20805f1132b2SJan Kara len = PAGE_CACHE_SIZE; 20815f1132b2SJan Kara clear_page_dirty_for_io(page); 20821c8349a1SNamjae Jeon err = ext4_bio_write_page(&mpd->io_submit, page, len, mpd->wbc, false); 20835f1132b2SJan Kara if (!err) 20845f1132b2SJan Kara mpd->wbc->nr_to_write--; 20855f1132b2SJan Kara mpd->first_page++; 20865f1132b2SJan Kara 20875f1132b2SJan Kara return err; 20885f1132b2SJan Kara } 20895f1132b2SJan Kara 20904e7ea81dSJan Kara #define BH_FLAGS ((1 << BH_Unwritten) | (1 << BH_Delay)) 20914e7ea81dSJan Kara 209261628a3fSMingming Cao /* 2093fffb2739SJan Kara * mballoc gives us at most this number of blocks... 2094fffb2739SJan Kara * XXX: That seems to be only a limitation of ext4_mb_normalize_request(). 2095fffb2739SJan Kara * The rest of mballoc seems to handle chunks up to full group size. 209661628a3fSMingming Cao */ 2097fffb2739SJan Kara #define MAX_WRITEPAGES_EXTENT_LEN 2048 2098525f4ed8SMingming Cao 2099525f4ed8SMingming Cao /* 21004e7ea81dSJan Kara * mpage_add_bh_to_extent - try to add bh to extent of blocks to map 21014e7ea81dSJan Kara * 21024e7ea81dSJan Kara * @mpd - extent of blocks 21034e7ea81dSJan Kara * @lblk - logical number of the block in the file 210409930042SJan Kara * @bh - buffer head we want to add to the extent 21054e7ea81dSJan Kara * 210609930042SJan Kara * The function is used to collect contig. blocks in the same state. If the 210709930042SJan Kara * buffer doesn't require mapping for writeback and we haven't started the 210809930042SJan Kara * extent of buffers to map yet, the function returns 'true' immediately - the 210909930042SJan Kara * caller can write the buffer right away. Otherwise the function returns true 211009930042SJan Kara * if the block has been added to the extent, false if the block couldn't be 211109930042SJan Kara * added. 21124e7ea81dSJan Kara */ 211309930042SJan Kara static bool mpage_add_bh_to_extent(struct mpage_da_data *mpd, ext4_lblk_t lblk, 211409930042SJan Kara struct buffer_head *bh) 21154e7ea81dSJan Kara { 21164e7ea81dSJan Kara struct ext4_map_blocks *map = &mpd->map; 21174e7ea81dSJan Kara 211809930042SJan Kara /* Buffer that doesn't need mapping for writeback? */ 211909930042SJan Kara if (!buffer_dirty(bh) || !buffer_mapped(bh) || 212009930042SJan Kara (!buffer_delay(bh) && !buffer_unwritten(bh))) { 212109930042SJan Kara /* So far no extent to map => we write the buffer right away */ 212209930042SJan Kara if (map->m_len == 0) 212309930042SJan Kara return true; 212409930042SJan Kara return false; 212509930042SJan Kara } 21264e7ea81dSJan Kara 21274e7ea81dSJan Kara /* First block in the extent? */ 21284e7ea81dSJan Kara if (map->m_len == 0) { 21294e7ea81dSJan Kara map->m_lblk = lblk; 21304e7ea81dSJan Kara map->m_len = 1; 213109930042SJan Kara map->m_flags = bh->b_state & BH_FLAGS; 213209930042SJan Kara return true; 21334e7ea81dSJan Kara } 21344e7ea81dSJan Kara 213509930042SJan Kara /* Don't go larger than mballoc is willing to allocate */ 213609930042SJan Kara if (map->m_len >= MAX_WRITEPAGES_EXTENT_LEN) 213709930042SJan Kara return false; 213809930042SJan Kara 21394e7ea81dSJan Kara /* Can we merge the block to our big extent? */ 21404e7ea81dSJan Kara if (lblk == map->m_lblk + map->m_len && 214109930042SJan Kara (bh->b_state & BH_FLAGS) == map->m_flags) { 21424e7ea81dSJan Kara map->m_len++; 214309930042SJan Kara return true; 21444e7ea81dSJan Kara } 214509930042SJan Kara return false; 21464e7ea81dSJan Kara } 21474e7ea81dSJan Kara 21485f1132b2SJan Kara /* 21495f1132b2SJan Kara * mpage_process_page_bufs - submit page buffers for IO or add them to extent 21505f1132b2SJan Kara * 21515f1132b2SJan Kara * @mpd - extent of blocks for mapping 21525f1132b2SJan Kara * @head - the first buffer in the page 21535f1132b2SJan Kara * @bh - buffer we should start processing from 21545f1132b2SJan Kara * @lblk - logical number of the block in the file corresponding to @bh 21555f1132b2SJan Kara * 21565f1132b2SJan Kara * Walk through page buffers from @bh upto @head (exclusive) and either submit 21575f1132b2SJan Kara * the page for IO if all buffers in this page were mapped and there's no 21585f1132b2SJan Kara * accumulated extent of buffers to map or add buffers in the page to the 21595f1132b2SJan Kara * extent of buffers to map. The function returns 1 if the caller can continue 21605f1132b2SJan Kara * by processing the next page, 0 if it should stop adding buffers to the 21615f1132b2SJan Kara * extent to map because we cannot extend it anymore. It can also return value 21625f1132b2SJan Kara * < 0 in case of error during IO submission. 21635f1132b2SJan Kara */ 21645f1132b2SJan Kara static int mpage_process_page_bufs(struct mpage_da_data *mpd, 21654e7ea81dSJan Kara struct buffer_head *head, 21664e7ea81dSJan Kara struct buffer_head *bh, 21674e7ea81dSJan Kara ext4_lblk_t lblk) 21684e7ea81dSJan Kara { 21694e7ea81dSJan Kara struct inode *inode = mpd->inode; 21705f1132b2SJan Kara int err; 21714e7ea81dSJan Kara ext4_lblk_t blocks = (i_size_read(inode) + (1 << inode->i_blkbits) - 1) 21724e7ea81dSJan Kara >> inode->i_blkbits; 21734e7ea81dSJan Kara 21744e7ea81dSJan Kara do { 21754e7ea81dSJan Kara BUG_ON(buffer_locked(bh)); 21764e7ea81dSJan Kara 217709930042SJan Kara if (lblk >= blocks || !mpage_add_bh_to_extent(mpd, lblk, bh)) { 21784e7ea81dSJan Kara /* Found extent to map? */ 21794e7ea81dSJan Kara if (mpd->map.m_len) 21805f1132b2SJan Kara return 0; 218109930042SJan Kara /* Everything mapped so far and we hit EOF */ 21825f1132b2SJan Kara break; 21834e7ea81dSJan Kara } 21844e7ea81dSJan Kara } while (lblk++, (bh = bh->b_this_page) != head); 21855f1132b2SJan Kara /* So far everything mapped? Submit the page for IO. */ 21865f1132b2SJan Kara if (mpd->map.m_len == 0) { 21875f1132b2SJan Kara err = mpage_submit_page(mpd, head->b_page); 21885f1132b2SJan Kara if (err < 0) 21894e7ea81dSJan Kara return err; 21904e7ea81dSJan Kara } 21915f1132b2SJan Kara return lblk < blocks; 21925f1132b2SJan Kara } 21934e7ea81dSJan Kara 21944e7ea81dSJan Kara /* 21954e7ea81dSJan Kara * mpage_map_buffers - update buffers corresponding to changed extent and 21964e7ea81dSJan Kara * submit fully mapped pages for IO 21974e7ea81dSJan Kara * 21984e7ea81dSJan Kara * @mpd - description of extent to map, on return next extent to map 21994e7ea81dSJan Kara * 22004e7ea81dSJan Kara * Scan buffers corresponding to changed extent (we expect corresponding pages 22014e7ea81dSJan Kara * to be already locked) and update buffer state according to new extent state. 22024e7ea81dSJan Kara * We map delalloc buffers to their physical location, clear unwritten bits, 2203556615dcSLukas Czerner * and mark buffers as uninit when we perform writes to unwritten extents 22044e7ea81dSJan Kara * and do extent conversion after IO is finished. If the last page is not fully 22054e7ea81dSJan Kara * mapped, we update @map to the next extent in the last page that needs 22064e7ea81dSJan Kara * mapping. Otherwise we submit the page for IO. 22074e7ea81dSJan Kara */ 22084e7ea81dSJan Kara static int mpage_map_and_submit_buffers(struct mpage_da_data *mpd) 22094e7ea81dSJan Kara { 22104e7ea81dSJan Kara struct pagevec pvec; 22114e7ea81dSJan Kara int nr_pages, i; 22124e7ea81dSJan Kara struct inode *inode = mpd->inode; 22134e7ea81dSJan Kara struct buffer_head *head, *bh; 22144e7ea81dSJan Kara int bpp_bits = PAGE_CACHE_SHIFT - inode->i_blkbits; 22154e7ea81dSJan Kara pgoff_t start, end; 22164e7ea81dSJan Kara ext4_lblk_t lblk; 22174e7ea81dSJan Kara sector_t pblock; 22184e7ea81dSJan Kara int err; 22194e7ea81dSJan Kara 22204e7ea81dSJan Kara start = mpd->map.m_lblk >> bpp_bits; 22214e7ea81dSJan Kara end = (mpd->map.m_lblk + mpd->map.m_len - 1) >> bpp_bits; 22224e7ea81dSJan Kara lblk = start << bpp_bits; 22234e7ea81dSJan Kara pblock = mpd->map.m_pblk; 22244e7ea81dSJan Kara 22254e7ea81dSJan Kara pagevec_init(&pvec, 0); 22264e7ea81dSJan Kara while (start <= end) { 22274e7ea81dSJan Kara nr_pages = pagevec_lookup(&pvec, inode->i_mapping, start, 22284e7ea81dSJan Kara PAGEVEC_SIZE); 22294e7ea81dSJan Kara if (nr_pages == 0) 22304e7ea81dSJan Kara break; 22314e7ea81dSJan Kara for (i = 0; i < nr_pages; i++) { 22324e7ea81dSJan Kara struct page *page = pvec.pages[i]; 22334e7ea81dSJan Kara 22344e7ea81dSJan Kara if (page->index > end) 22354e7ea81dSJan Kara break; 22364e7ea81dSJan Kara /* Up to 'end' pages must be contiguous */ 22374e7ea81dSJan Kara BUG_ON(page->index != start); 22384e7ea81dSJan Kara bh = head = page_buffers(page); 22394e7ea81dSJan Kara do { 22404e7ea81dSJan Kara if (lblk < mpd->map.m_lblk) 22414e7ea81dSJan Kara continue; 22424e7ea81dSJan Kara if (lblk >= mpd->map.m_lblk + mpd->map.m_len) { 22434e7ea81dSJan Kara /* 22444e7ea81dSJan Kara * Buffer after end of mapped extent. 22454e7ea81dSJan Kara * Find next buffer in the page to map. 22464e7ea81dSJan Kara */ 22474e7ea81dSJan Kara mpd->map.m_len = 0; 22484e7ea81dSJan Kara mpd->map.m_flags = 0; 22495f1132b2SJan Kara /* 22505f1132b2SJan Kara * FIXME: If dioread_nolock supports 22515f1132b2SJan Kara * blocksize < pagesize, we need to make 22525f1132b2SJan Kara * sure we add size mapped so far to 22535f1132b2SJan Kara * io_end->size as the following call 22545f1132b2SJan Kara * can submit the page for IO. 22555f1132b2SJan Kara */ 22565f1132b2SJan Kara err = mpage_process_page_bufs(mpd, head, 22575f1132b2SJan Kara bh, lblk); 22584e7ea81dSJan Kara pagevec_release(&pvec); 22595f1132b2SJan Kara if (err > 0) 22605f1132b2SJan Kara err = 0; 22615f1132b2SJan Kara return err; 22624e7ea81dSJan Kara } 22634e7ea81dSJan Kara if (buffer_delay(bh)) { 22644e7ea81dSJan Kara clear_buffer_delay(bh); 22654e7ea81dSJan Kara bh->b_blocknr = pblock++; 22664e7ea81dSJan Kara } 22674e7ea81dSJan Kara clear_buffer_unwritten(bh); 22685f1132b2SJan Kara } while (lblk++, (bh = bh->b_this_page) != head); 22694e7ea81dSJan Kara 22704e7ea81dSJan Kara /* 22714e7ea81dSJan Kara * FIXME: This is going to break if dioread_nolock 22724e7ea81dSJan Kara * supports blocksize < pagesize as we will try to 22734e7ea81dSJan Kara * convert potentially unmapped parts of inode. 22744e7ea81dSJan Kara */ 22754e7ea81dSJan Kara mpd->io_submit.io_end->size += PAGE_CACHE_SIZE; 22764e7ea81dSJan Kara /* Page fully mapped - let IO run! */ 22774e7ea81dSJan Kara err = mpage_submit_page(mpd, page); 22784e7ea81dSJan Kara if (err < 0) { 22794e7ea81dSJan Kara pagevec_release(&pvec); 22804e7ea81dSJan Kara return err; 22814e7ea81dSJan Kara } 22824e7ea81dSJan Kara start++; 22834e7ea81dSJan Kara } 22844e7ea81dSJan Kara pagevec_release(&pvec); 22854e7ea81dSJan Kara } 22864e7ea81dSJan Kara /* Extent fully mapped and matches with page boundary. We are done. */ 22874e7ea81dSJan Kara mpd->map.m_len = 0; 22884e7ea81dSJan Kara mpd->map.m_flags = 0; 22894e7ea81dSJan Kara return 0; 22904e7ea81dSJan Kara } 22914e7ea81dSJan Kara 22924e7ea81dSJan Kara static int mpage_map_one_extent(handle_t *handle, struct mpage_da_data *mpd) 22934e7ea81dSJan Kara { 22944e7ea81dSJan Kara struct inode *inode = mpd->inode; 22954e7ea81dSJan Kara struct ext4_map_blocks *map = &mpd->map; 22964e7ea81dSJan Kara int get_blocks_flags; 2297090f32eeSLukas Czerner int err, dioread_nolock; 22984e7ea81dSJan Kara 22994e7ea81dSJan Kara trace_ext4_da_write_pages_extent(inode, map); 23004e7ea81dSJan Kara /* 23014e7ea81dSJan Kara * Call ext4_map_blocks() to allocate any delayed allocation blocks, or 2302556615dcSLukas Czerner * to convert an unwritten extent to be initialized (in the case 23034e7ea81dSJan Kara * where we have written into one or more preallocated blocks). It is 23044e7ea81dSJan Kara * possible that we're going to need more metadata blocks than 23054e7ea81dSJan Kara * previously reserved. However we must not fail because we're in 23064e7ea81dSJan Kara * writeback and there is nothing we can do about it so it might result 23074e7ea81dSJan Kara * in data loss. So use reserved blocks to allocate metadata if 23084e7ea81dSJan Kara * possible. 23094e7ea81dSJan Kara * 2310754cfed6STheodore Ts'o * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE if 2311754cfed6STheodore Ts'o * the blocks in question are delalloc blocks. This indicates 2312754cfed6STheodore Ts'o * that the blocks and quotas has already been checked when 2313754cfed6STheodore Ts'o * the data was copied into the page cache. 23144e7ea81dSJan Kara */ 23154e7ea81dSJan Kara get_blocks_flags = EXT4_GET_BLOCKS_CREATE | 23164e7ea81dSJan Kara EXT4_GET_BLOCKS_METADATA_NOFAIL; 2317090f32eeSLukas Czerner dioread_nolock = ext4_should_dioread_nolock(inode); 2318090f32eeSLukas Czerner if (dioread_nolock) 23194e7ea81dSJan Kara get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT; 23204e7ea81dSJan Kara if (map->m_flags & (1 << BH_Delay)) 23214e7ea81dSJan Kara get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE; 23224e7ea81dSJan Kara 23234e7ea81dSJan Kara err = ext4_map_blocks(handle, inode, map, get_blocks_flags); 23244e7ea81dSJan Kara if (err < 0) 23254e7ea81dSJan Kara return err; 2326090f32eeSLukas Czerner if (dioread_nolock && (map->m_flags & EXT4_MAP_UNWRITTEN)) { 23276b523df4SJan Kara if (!mpd->io_submit.io_end->handle && 23286b523df4SJan Kara ext4_handle_valid(handle)) { 23296b523df4SJan Kara mpd->io_submit.io_end->handle = handle->h_rsv_handle; 23306b523df4SJan Kara handle->h_rsv_handle = NULL; 23316b523df4SJan Kara } 23323613d228SJan Kara ext4_set_io_unwritten_flag(inode, mpd->io_submit.io_end); 23336b523df4SJan Kara } 23344e7ea81dSJan Kara 23354e7ea81dSJan Kara BUG_ON(map->m_len == 0); 23364e7ea81dSJan Kara if (map->m_flags & EXT4_MAP_NEW) { 23374e7ea81dSJan Kara struct block_device *bdev = inode->i_sb->s_bdev; 23384e7ea81dSJan Kara int i; 23394e7ea81dSJan Kara 23404e7ea81dSJan Kara for (i = 0; i < map->m_len; i++) 23414e7ea81dSJan Kara unmap_underlying_metadata(bdev, map->m_pblk + i); 23424e7ea81dSJan Kara } 23434e7ea81dSJan Kara return 0; 23444e7ea81dSJan Kara } 23454e7ea81dSJan Kara 23464e7ea81dSJan Kara /* 23474e7ea81dSJan Kara * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length 23484e7ea81dSJan Kara * mpd->len and submit pages underlying it for IO 23494e7ea81dSJan Kara * 23504e7ea81dSJan Kara * @handle - handle for journal operations 23514e7ea81dSJan Kara * @mpd - extent to map 23527534e854SJan Kara * @give_up_on_write - we set this to true iff there is a fatal error and there 23537534e854SJan Kara * is no hope of writing the data. The caller should discard 23547534e854SJan Kara * dirty pages to avoid infinite loops. 23554e7ea81dSJan Kara * 23564e7ea81dSJan Kara * The function maps extent starting at mpd->lblk of length mpd->len. If it is 23574e7ea81dSJan Kara * delayed, blocks are allocated, if it is unwritten, we may need to convert 23584e7ea81dSJan Kara * them to initialized or split the described range from larger unwritten 23594e7ea81dSJan Kara * extent. Note that we need not map all the described range since allocation 23604e7ea81dSJan Kara * can return less blocks or the range is covered by more unwritten extents. We 23614e7ea81dSJan Kara * cannot map more because we are limited by reserved transaction credits. On 23624e7ea81dSJan Kara * the other hand we always make sure that the last touched page is fully 23634e7ea81dSJan Kara * mapped so that it can be written out (and thus forward progress is 23644e7ea81dSJan Kara * guaranteed). After mapping we submit all mapped pages for IO. 23654e7ea81dSJan Kara */ 23664e7ea81dSJan Kara static int mpage_map_and_submit_extent(handle_t *handle, 2367cb530541STheodore Ts'o struct mpage_da_data *mpd, 2368cb530541STheodore Ts'o bool *give_up_on_write) 23694e7ea81dSJan Kara { 23704e7ea81dSJan Kara struct inode *inode = mpd->inode; 23714e7ea81dSJan Kara struct ext4_map_blocks *map = &mpd->map; 23724e7ea81dSJan Kara int err; 23734e7ea81dSJan Kara loff_t disksize; 23746603120eSDmitry Monakhov int progress = 0; 23754e7ea81dSJan Kara 23764e7ea81dSJan Kara mpd->io_submit.io_end->offset = 23774e7ea81dSJan Kara ((loff_t)map->m_lblk) << inode->i_blkbits; 237827d7c4edSJan Kara do { 23794e7ea81dSJan Kara err = mpage_map_one_extent(handle, mpd); 23804e7ea81dSJan Kara if (err < 0) { 23814e7ea81dSJan Kara struct super_block *sb = inode->i_sb; 23824e7ea81dSJan Kara 2383cb530541STheodore Ts'o if (EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED) 2384cb530541STheodore Ts'o goto invalidate_dirty_pages; 23854e7ea81dSJan Kara /* 2386cb530541STheodore Ts'o * Let the uper layers retry transient errors. 2387cb530541STheodore Ts'o * In the case of ENOSPC, if ext4_count_free_blocks() 2388cb530541STheodore Ts'o * is non-zero, a commit should free up blocks. 23894e7ea81dSJan Kara */ 2390cb530541STheodore Ts'o if ((err == -ENOMEM) || 23916603120eSDmitry Monakhov (err == -ENOSPC && ext4_count_free_clusters(sb))) { 23926603120eSDmitry Monakhov if (progress) 23936603120eSDmitry Monakhov goto update_disksize; 2394cb530541STheodore Ts'o return err; 23956603120eSDmitry Monakhov } 23964e7ea81dSJan Kara ext4_msg(sb, KERN_CRIT, 23974e7ea81dSJan Kara "Delayed block allocation failed for " 23984e7ea81dSJan Kara "inode %lu at logical offset %llu with" 23994e7ea81dSJan Kara " max blocks %u with error %d", 24004e7ea81dSJan Kara inode->i_ino, 24014e7ea81dSJan Kara (unsigned long long)map->m_lblk, 2402cb530541STheodore Ts'o (unsigned)map->m_len, -err); 24034e7ea81dSJan Kara ext4_msg(sb, KERN_CRIT, 24044e7ea81dSJan Kara "This should not happen!! Data will " 24054e7ea81dSJan Kara "be lost\n"); 24064e7ea81dSJan Kara if (err == -ENOSPC) 24074e7ea81dSJan Kara ext4_print_free_blocks(inode); 2408cb530541STheodore Ts'o invalidate_dirty_pages: 2409cb530541STheodore Ts'o *give_up_on_write = true; 24104e7ea81dSJan Kara return err; 24114e7ea81dSJan Kara } 24126603120eSDmitry Monakhov progress = 1; 24134e7ea81dSJan Kara /* 24144e7ea81dSJan Kara * Update buffer state, submit mapped pages, and get us new 24154e7ea81dSJan Kara * extent to map 24164e7ea81dSJan Kara */ 24174e7ea81dSJan Kara err = mpage_map_and_submit_buffers(mpd); 24184e7ea81dSJan Kara if (err < 0) 24196603120eSDmitry Monakhov goto update_disksize; 242027d7c4edSJan Kara } while (map->m_len); 24214e7ea81dSJan Kara 24226603120eSDmitry Monakhov update_disksize: 2423622cad13STheodore Ts'o /* 2424622cad13STheodore Ts'o * Update on-disk size after IO is submitted. Races with 2425622cad13STheodore Ts'o * truncate are avoided by checking i_size under i_data_sem. 2426622cad13STheodore Ts'o */ 24274e7ea81dSJan Kara disksize = ((loff_t)mpd->first_page) << PAGE_CACHE_SHIFT; 24284e7ea81dSJan Kara if (disksize > EXT4_I(inode)->i_disksize) { 24294e7ea81dSJan Kara int err2; 2430622cad13STheodore Ts'o loff_t i_size; 24314e7ea81dSJan Kara 2432622cad13STheodore Ts'o down_write(&EXT4_I(inode)->i_data_sem); 2433622cad13STheodore Ts'o i_size = i_size_read(inode); 2434622cad13STheodore Ts'o if (disksize > i_size) 2435622cad13STheodore Ts'o disksize = i_size; 2436622cad13STheodore Ts'o if (disksize > EXT4_I(inode)->i_disksize) 2437622cad13STheodore Ts'o EXT4_I(inode)->i_disksize = disksize; 24384e7ea81dSJan Kara err2 = ext4_mark_inode_dirty(handle, inode); 2439622cad13STheodore Ts'o up_write(&EXT4_I(inode)->i_data_sem); 24404e7ea81dSJan Kara if (err2) 24414e7ea81dSJan Kara ext4_error(inode->i_sb, 24424e7ea81dSJan Kara "Failed to mark inode %lu dirty", 24434e7ea81dSJan Kara inode->i_ino); 24444e7ea81dSJan Kara if (!err) 24454e7ea81dSJan Kara err = err2; 24464e7ea81dSJan Kara } 24474e7ea81dSJan Kara return err; 24484e7ea81dSJan Kara } 24494e7ea81dSJan Kara 24504e7ea81dSJan Kara /* 2451fffb2739SJan Kara * Calculate the total number of credits to reserve for one writepages 245220970ba6STheodore Ts'o * iteration. This is called from ext4_writepages(). We map an extent of 2453fffb2739SJan Kara * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping 2454fffb2739SJan Kara * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN + 2455fffb2739SJan Kara * bpp - 1 blocks in bpp different extents. 2456525f4ed8SMingming Cao */ 2457fffb2739SJan Kara static int ext4_da_writepages_trans_blocks(struct inode *inode) 2458fffb2739SJan Kara { 2459fffb2739SJan Kara int bpp = ext4_journal_blocks_per_page(inode); 2460525f4ed8SMingming Cao 2461fffb2739SJan Kara return ext4_meta_trans_blocks(inode, 2462fffb2739SJan Kara MAX_WRITEPAGES_EXTENT_LEN + bpp - 1, bpp); 2463525f4ed8SMingming Cao } 246461628a3fSMingming Cao 24658e48dcfbSTheodore Ts'o /* 24664e7ea81dSJan Kara * mpage_prepare_extent_to_map - find & lock contiguous range of dirty pages 24674e7ea81dSJan Kara * and underlying extent to map 24684e7ea81dSJan Kara * 24694e7ea81dSJan Kara * @mpd - where to look for pages 24704e7ea81dSJan Kara * 24714e7ea81dSJan Kara * Walk dirty pages in the mapping. If they are fully mapped, submit them for 24724e7ea81dSJan Kara * IO immediately. When we find a page which isn't mapped we start accumulating 24734e7ea81dSJan Kara * extent of buffers underlying these pages that needs mapping (formed by 24744e7ea81dSJan Kara * either delayed or unwritten buffers). We also lock the pages containing 24754e7ea81dSJan Kara * these buffers. The extent found is returned in @mpd structure (starting at 24764e7ea81dSJan Kara * mpd->lblk with length mpd->len blocks). 24774e7ea81dSJan Kara * 24784e7ea81dSJan Kara * Note that this function can attach bios to one io_end structure which are 24794e7ea81dSJan Kara * neither logically nor physically contiguous. Although it may seem as an 24804e7ea81dSJan Kara * unnecessary complication, it is actually inevitable in blocksize < pagesize 24814e7ea81dSJan Kara * case as we need to track IO to all buffers underlying a page in one io_end. 24828e48dcfbSTheodore Ts'o */ 24834e7ea81dSJan Kara static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd) 24848e48dcfbSTheodore Ts'o { 24854e7ea81dSJan Kara struct address_space *mapping = mpd->inode->i_mapping; 24868e48dcfbSTheodore Ts'o struct pagevec pvec; 24874f01b02cSTheodore Ts'o unsigned int nr_pages; 2488aeac589aSMing Lei long left = mpd->wbc->nr_to_write; 24894e7ea81dSJan Kara pgoff_t index = mpd->first_page; 24904e7ea81dSJan Kara pgoff_t end = mpd->last_page; 24914e7ea81dSJan Kara int tag; 24924e7ea81dSJan Kara int i, err = 0; 24934e7ea81dSJan Kara int blkbits = mpd->inode->i_blkbits; 24944e7ea81dSJan Kara ext4_lblk_t lblk; 24954e7ea81dSJan Kara struct buffer_head *head; 24968e48dcfbSTheodore Ts'o 24974e7ea81dSJan Kara if (mpd->wbc->sync_mode == WB_SYNC_ALL || mpd->wbc->tagged_writepages) 24985b41d924SEric Sandeen tag = PAGECACHE_TAG_TOWRITE; 24995b41d924SEric Sandeen else 25005b41d924SEric Sandeen tag = PAGECACHE_TAG_DIRTY; 25015b41d924SEric Sandeen 25024e7ea81dSJan Kara pagevec_init(&pvec, 0); 25034e7ea81dSJan Kara mpd->map.m_len = 0; 25044e7ea81dSJan Kara mpd->next_page = index; 25054f01b02cSTheodore Ts'o while (index <= end) { 25065b41d924SEric Sandeen nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag, 25078e48dcfbSTheodore Ts'o min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1); 25088e48dcfbSTheodore Ts'o if (nr_pages == 0) 25094e7ea81dSJan Kara goto out; 25108e48dcfbSTheodore Ts'o 25118e48dcfbSTheodore Ts'o for (i = 0; i < nr_pages; i++) { 25128e48dcfbSTheodore Ts'o struct page *page = pvec.pages[i]; 25138e48dcfbSTheodore Ts'o 25148e48dcfbSTheodore Ts'o /* 25158e48dcfbSTheodore Ts'o * At this point, the page may be truncated or 25168e48dcfbSTheodore Ts'o * invalidated (changing page->mapping to NULL), or 25178e48dcfbSTheodore Ts'o * even swizzled back from swapper_space to tmpfs file 25188e48dcfbSTheodore Ts'o * mapping. However, page->index will not change 25198e48dcfbSTheodore Ts'o * because we have a reference on the page. 25208e48dcfbSTheodore Ts'o */ 25214f01b02cSTheodore Ts'o if (page->index > end) 25224f01b02cSTheodore Ts'o goto out; 25238e48dcfbSTheodore Ts'o 2524aeac589aSMing Lei /* 2525aeac589aSMing Lei * Accumulated enough dirty pages? This doesn't apply 2526aeac589aSMing Lei * to WB_SYNC_ALL mode. For integrity sync we have to 2527aeac589aSMing Lei * keep going because someone may be concurrently 2528aeac589aSMing Lei * dirtying pages, and we might have synced a lot of 2529aeac589aSMing Lei * newly appeared dirty pages, but have not synced all 2530aeac589aSMing Lei * of the old dirty pages. 2531aeac589aSMing Lei */ 2532aeac589aSMing Lei if (mpd->wbc->sync_mode == WB_SYNC_NONE && left <= 0) 2533aeac589aSMing Lei goto out; 2534aeac589aSMing Lei 25354e7ea81dSJan Kara /* If we can't merge this page, we are done. */ 25364e7ea81dSJan Kara if (mpd->map.m_len > 0 && mpd->next_page != page->index) 25374e7ea81dSJan Kara goto out; 253878aaced3STheodore Ts'o 25398e48dcfbSTheodore Ts'o lock_page(page); 25408e48dcfbSTheodore Ts'o /* 25414e7ea81dSJan Kara * If the page is no longer dirty, or its mapping no 25424e7ea81dSJan Kara * longer corresponds to inode we are writing (which 25434e7ea81dSJan Kara * means it has been truncated or invalidated), or the 25444e7ea81dSJan Kara * page is already under writeback and we are not doing 25454e7ea81dSJan Kara * a data integrity writeback, skip the page 25468e48dcfbSTheodore Ts'o */ 25474f01b02cSTheodore Ts'o if (!PageDirty(page) || 25484f01b02cSTheodore Ts'o (PageWriteback(page) && 25494e7ea81dSJan Kara (mpd->wbc->sync_mode == WB_SYNC_NONE)) || 25504f01b02cSTheodore Ts'o unlikely(page->mapping != mapping)) { 25518e48dcfbSTheodore Ts'o unlock_page(page); 25528e48dcfbSTheodore Ts'o continue; 25538e48dcfbSTheodore Ts'o } 25548e48dcfbSTheodore Ts'o 25558e48dcfbSTheodore Ts'o wait_on_page_writeback(page); 25568e48dcfbSTheodore Ts'o BUG_ON(PageWriteback(page)); 25578e48dcfbSTheodore Ts'o 25584e7ea81dSJan Kara if (mpd->map.m_len == 0) 25598eb9e5ceSTheodore Ts'o mpd->first_page = page->index; 25608eb9e5ceSTheodore Ts'o mpd->next_page = page->index + 1; 2561f8bec370SJan Kara /* Add all dirty buffers to mpd */ 25624e7ea81dSJan Kara lblk = ((ext4_lblk_t)page->index) << 25634e7ea81dSJan Kara (PAGE_CACHE_SHIFT - blkbits); 25648eb9e5ceSTheodore Ts'o head = page_buffers(page); 25655f1132b2SJan Kara err = mpage_process_page_bufs(mpd, head, head, lblk); 25665f1132b2SJan Kara if (err <= 0) 25674e7ea81dSJan Kara goto out; 25685f1132b2SJan Kara err = 0; 2569aeac589aSMing Lei left--; 25708e48dcfbSTheodore Ts'o } 25718e48dcfbSTheodore Ts'o pagevec_release(&pvec); 25728e48dcfbSTheodore Ts'o cond_resched(); 25738e48dcfbSTheodore Ts'o } 25744f01b02cSTheodore Ts'o return 0; 25758eb9e5ceSTheodore Ts'o out: 25768eb9e5ceSTheodore Ts'o pagevec_release(&pvec); 25774e7ea81dSJan Kara return err; 25788e48dcfbSTheodore Ts'o } 25798e48dcfbSTheodore Ts'o 258020970ba6STheodore Ts'o static int __writepage(struct page *page, struct writeback_control *wbc, 258120970ba6STheodore Ts'o void *data) 258220970ba6STheodore Ts'o { 258320970ba6STheodore Ts'o struct address_space *mapping = data; 258420970ba6STheodore Ts'o int ret = ext4_writepage(page, wbc); 258520970ba6STheodore Ts'o mapping_set_error(mapping, ret); 258620970ba6STheodore Ts'o return ret; 258720970ba6STheodore Ts'o } 258820970ba6STheodore Ts'o 258920970ba6STheodore Ts'o static int ext4_writepages(struct address_space *mapping, 259064769240SAlex Tomas struct writeback_control *wbc) 259164769240SAlex Tomas { 25924e7ea81dSJan Kara pgoff_t writeback_index = 0; 25934e7ea81dSJan Kara long nr_to_write = wbc->nr_to_write; 259422208dedSAneesh Kumar K.V int range_whole = 0; 25954e7ea81dSJan Kara int cycled = 1; 259661628a3fSMingming Cao handle_t *handle = NULL; 2597df22291fSAneesh Kumar K.V struct mpage_da_data mpd; 25985e745b04SAneesh Kumar K.V struct inode *inode = mapping->host; 25996b523df4SJan Kara int needed_blocks, rsv_blocks = 0, ret = 0; 26005e745b04SAneesh Kumar K.V struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb); 26014e7ea81dSJan Kara bool done; 26021bce63d1SShaohua Li struct blk_plug plug; 2603cb530541STheodore Ts'o bool give_up_on_write = false; 260461628a3fSMingming Cao 260520970ba6STheodore Ts'o trace_ext4_writepages(inode, wbc); 2606ba80b101STheodore Ts'o 260761628a3fSMingming Cao /* 260861628a3fSMingming Cao * No pages to write? This is mainly a kludge to avoid starting 260961628a3fSMingming Cao * a transaction for special inodes like journal inode on last iput() 261061628a3fSMingming Cao * because that could violate lock ordering on umount 261161628a3fSMingming Cao */ 2612a1d6cc56SAneesh Kumar K.V if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) 2613bbf023c7SMing Lei goto out_writepages; 26142a21e37eSTheodore Ts'o 261520970ba6STheodore Ts'o if (ext4_should_journal_data(inode)) { 261620970ba6STheodore Ts'o struct blk_plug plug; 261720970ba6STheodore Ts'o 261820970ba6STheodore Ts'o blk_start_plug(&plug); 261920970ba6STheodore Ts'o ret = write_cache_pages(mapping, wbc, __writepage, mapping); 262020970ba6STheodore Ts'o blk_finish_plug(&plug); 2621bbf023c7SMing Lei goto out_writepages; 262220970ba6STheodore Ts'o } 262320970ba6STheodore Ts'o 26242a21e37eSTheodore Ts'o /* 26252a21e37eSTheodore Ts'o * If the filesystem has aborted, it is read-only, so return 26262a21e37eSTheodore Ts'o * right away instead of dumping stack traces later on that 26272a21e37eSTheodore Ts'o * will obscure the real source of the problem. We test 26284ab2f15bSTheodore Ts'o * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because 26292a21e37eSTheodore Ts'o * the latter could be true if the filesystem is mounted 263020970ba6STheodore Ts'o * read-only, and in that case, ext4_writepages should 26312a21e37eSTheodore Ts'o * *never* be called, so if that ever happens, we would want 26322a21e37eSTheodore Ts'o * the stack trace. 26332a21e37eSTheodore Ts'o */ 2634bbf023c7SMing Lei if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED)) { 2635bbf023c7SMing Lei ret = -EROFS; 2636bbf023c7SMing Lei goto out_writepages; 2637bbf023c7SMing Lei } 26382a21e37eSTheodore Ts'o 26396b523df4SJan Kara if (ext4_should_dioread_nolock(inode)) { 26406b523df4SJan Kara /* 26416b523df4SJan Kara * We may need to convert up to one extent per block in 26426b523df4SJan Kara * the page and we may dirty the inode. 26436b523df4SJan Kara */ 26446b523df4SJan Kara rsv_blocks = 1 + (PAGE_CACHE_SIZE >> inode->i_blkbits); 26456b523df4SJan Kara } 26466b523df4SJan Kara 26474e7ea81dSJan Kara /* 26484e7ea81dSJan Kara * If we have inline data and arrive here, it means that 26494e7ea81dSJan Kara * we will soon create the block for the 1st page, so 26504e7ea81dSJan Kara * we'd better clear the inline data here. 26514e7ea81dSJan Kara */ 26524e7ea81dSJan Kara if (ext4_has_inline_data(inode)) { 26534e7ea81dSJan Kara /* Just inode will be modified... */ 26544e7ea81dSJan Kara handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 26554e7ea81dSJan Kara if (IS_ERR(handle)) { 26564e7ea81dSJan Kara ret = PTR_ERR(handle); 26574e7ea81dSJan Kara goto out_writepages; 26584e7ea81dSJan Kara } 26594e7ea81dSJan Kara BUG_ON(ext4_test_inode_state(inode, 26604e7ea81dSJan Kara EXT4_STATE_MAY_INLINE_DATA)); 26614e7ea81dSJan Kara ext4_destroy_inline_data(handle, inode); 26624e7ea81dSJan Kara ext4_journal_stop(handle); 26634e7ea81dSJan Kara } 26644e7ea81dSJan Kara 266522208dedSAneesh Kumar K.V if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) 266622208dedSAneesh Kumar K.V range_whole = 1; 266761628a3fSMingming Cao 26682acf2c26SAneesh Kumar K.V if (wbc->range_cyclic) { 26694e7ea81dSJan Kara writeback_index = mapping->writeback_index; 26704e7ea81dSJan Kara if (writeback_index) 26712acf2c26SAneesh Kumar K.V cycled = 0; 26724e7ea81dSJan Kara mpd.first_page = writeback_index; 26734e7ea81dSJan Kara mpd.last_page = -1; 26745b41d924SEric Sandeen } else { 26754e7ea81dSJan Kara mpd.first_page = wbc->range_start >> PAGE_CACHE_SHIFT; 26764e7ea81dSJan Kara mpd.last_page = wbc->range_end >> PAGE_CACHE_SHIFT; 26775b41d924SEric Sandeen } 2678a1d6cc56SAneesh Kumar K.V 26794e7ea81dSJan Kara mpd.inode = inode; 26804e7ea81dSJan Kara mpd.wbc = wbc; 26814e7ea81dSJan Kara ext4_io_submit_init(&mpd.io_submit, wbc); 26822acf2c26SAneesh Kumar K.V retry: 26836e6938b6SWu Fengguang if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages) 26844e7ea81dSJan Kara tag_pages_for_writeback(mapping, mpd.first_page, mpd.last_page); 26854e7ea81dSJan Kara done = false; 26861bce63d1SShaohua Li blk_start_plug(&plug); 26874e7ea81dSJan Kara while (!done && mpd.first_page <= mpd.last_page) { 26884e7ea81dSJan Kara /* For each extent of pages we use new io_end */ 26894e7ea81dSJan Kara mpd.io_submit.io_end = ext4_init_io_end(inode, GFP_KERNEL); 26904e7ea81dSJan Kara if (!mpd.io_submit.io_end) { 26914e7ea81dSJan Kara ret = -ENOMEM; 26924e7ea81dSJan Kara break; 26934e7ea81dSJan Kara } 2694a1d6cc56SAneesh Kumar K.V 2695a1d6cc56SAneesh Kumar K.V /* 26964e7ea81dSJan Kara * We have two constraints: We find one extent to map and we 26974e7ea81dSJan Kara * must always write out whole page (makes a difference when 26984e7ea81dSJan Kara * blocksize < pagesize) so that we don't block on IO when we 26994e7ea81dSJan Kara * try to write out the rest of the page. Journalled mode is 27004e7ea81dSJan Kara * not supported by delalloc. 2701a1d6cc56SAneesh Kumar K.V */ 2702a1d6cc56SAneesh Kumar K.V BUG_ON(ext4_should_journal_data(inode)); 2703525f4ed8SMingming Cao needed_blocks = ext4_da_writepages_trans_blocks(inode); 2704a1d6cc56SAneesh Kumar K.V 270561628a3fSMingming Cao /* start a new transaction */ 27066b523df4SJan Kara handle = ext4_journal_start_with_reserve(inode, 27076b523df4SJan Kara EXT4_HT_WRITE_PAGE, needed_blocks, rsv_blocks); 270861628a3fSMingming Cao if (IS_ERR(handle)) { 270961628a3fSMingming Cao ret = PTR_ERR(handle); 27101693918eSTheodore Ts'o ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: " 2711fbe845ddSCurt Wohlgemuth "%ld pages, ino %lu; err %d", __func__, 2712a1d6cc56SAneesh Kumar K.V wbc->nr_to_write, inode->i_ino, ret); 27134e7ea81dSJan Kara /* Release allocated io_end */ 27144e7ea81dSJan Kara ext4_put_io_end(mpd.io_submit.io_end); 27154e7ea81dSJan Kara break; 271661628a3fSMingming Cao } 2717f63e6005STheodore Ts'o 27184e7ea81dSJan Kara trace_ext4_da_write_pages(inode, mpd.first_page, mpd.wbc); 27194e7ea81dSJan Kara ret = mpage_prepare_extent_to_map(&mpd); 27204e7ea81dSJan Kara if (!ret) { 27214e7ea81dSJan Kara if (mpd.map.m_len) 2722cb530541STheodore Ts'o ret = mpage_map_and_submit_extent(handle, &mpd, 2723cb530541STheodore Ts'o &give_up_on_write); 27244e7ea81dSJan Kara else { 2725f63e6005STheodore Ts'o /* 27264e7ea81dSJan Kara * We scanned the whole range (or exhausted 27274e7ea81dSJan Kara * nr_to_write), submitted what was mapped and 27284e7ea81dSJan Kara * didn't find anything needing mapping. We are 27294e7ea81dSJan Kara * done. 2730f63e6005STheodore Ts'o */ 27314e7ea81dSJan Kara done = true; 2732f63e6005STheodore Ts'o } 27334e7ea81dSJan Kara } 273461628a3fSMingming Cao ext4_journal_stop(handle); 27354e7ea81dSJan Kara /* Submit prepared bio */ 27364e7ea81dSJan Kara ext4_io_submit(&mpd.io_submit); 27374e7ea81dSJan Kara /* Unlock pages we didn't use */ 2738cb530541STheodore Ts'o mpage_release_unused_pages(&mpd, give_up_on_write); 27394e7ea81dSJan Kara /* Drop our io_end reference we got from init */ 27404e7ea81dSJan Kara ext4_put_io_end(mpd.io_submit.io_end); 2741df22291fSAneesh Kumar K.V 27424e7ea81dSJan Kara if (ret == -ENOSPC && sbi->s_journal) { 27434e7ea81dSJan Kara /* 27444e7ea81dSJan Kara * Commit the transaction which would 274522208dedSAneesh Kumar K.V * free blocks released in the transaction 274622208dedSAneesh Kumar K.V * and try again 274722208dedSAneesh Kumar K.V */ 2748df22291fSAneesh Kumar K.V jbd2_journal_force_commit_nested(sbi->s_journal); 274922208dedSAneesh Kumar K.V ret = 0; 27504e7ea81dSJan Kara continue; 27514e7ea81dSJan Kara } 27524e7ea81dSJan Kara /* Fatal error - ENOMEM, EIO... */ 27534e7ea81dSJan Kara if (ret) 275461628a3fSMingming Cao break; 275561628a3fSMingming Cao } 27561bce63d1SShaohua Li blk_finish_plug(&plug); 27579c12a831SJan Kara if (!ret && !cycled && wbc->nr_to_write > 0) { 27582acf2c26SAneesh Kumar K.V cycled = 1; 27594e7ea81dSJan Kara mpd.last_page = writeback_index - 1; 27604e7ea81dSJan Kara mpd.first_page = 0; 27612acf2c26SAneesh Kumar K.V goto retry; 27622acf2c26SAneesh Kumar K.V } 276361628a3fSMingming Cao 276422208dedSAneesh Kumar K.V /* Update index */ 276522208dedSAneesh Kumar K.V if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) 276622208dedSAneesh Kumar K.V /* 27674e7ea81dSJan Kara * Set the writeback_index so that range_cyclic 276822208dedSAneesh Kumar K.V * mode will write it back later 276922208dedSAneesh Kumar K.V */ 27704e7ea81dSJan Kara mapping->writeback_index = mpd.first_page; 2771a1d6cc56SAneesh Kumar K.V 277261628a3fSMingming Cao out_writepages: 277320970ba6STheodore Ts'o trace_ext4_writepages_result(inode, wbc, ret, 27744e7ea81dSJan Kara nr_to_write - wbc->nr_to_write); 277561628a3fSMingming Cao return ret; 277664769240SAlex Tomas } 277764769240SAlex Tomas 277879f0be8dSAneesh Kumar K.V static int ext4_nonda_switch(struct super_block *sb) 277979f0be8dSAneesh Kumar K.V { 27805c1ff336SEric Whitney s64 free_clusters, dirty_clusters; 278179f0be8dSAneesh Kumar K.V struct ext4_sb_info *sbi = EXT4_SB(sb); 278279f0be8dSAneesh Kumar K.V 278379f0be8dSAneesh Kumar K.V /* 278479f0be8dSAneesh Kumar K.V * switch to non delalloc mode if we are running low 278579f0be8dSAneesh Kumar K.V * on free block. The free block accounting via percpu 2786179f7ebfSEric Dumazet * counters can get slightly wrong with percpu_counter_batch getting 278779f0be8dSAneesh Kumar K.V * accumulated on each CPU without updating global counters 278879f0be8dSAneesh Kumar K.V * Delalloc need an accurate free block accounting. So switch 278979f0be8dSAneesh Kumar K.V * to non delalloc when we are near to error range. 279079f0be8dSAneesh Kumar K.V */ 27915c1ff336SEric Whitney free_clusters = 27925c1ff336SEric Whitney percpu_counter_read_positive(&sbi->s_freeclusters_counter); 27935c1ff336SEric Whitney dirty_clusters = 27945c1ff336SEric Whitney percpu_counter_read_positive(&sbi->s_dirtyclusters_counter); 279500d4e736STheodore Ts'o /* 279600d4e736STheodore Ts'o * Start pushing delalloc when 1/2 of free blocks are dirty. 279700d4e736STheodore Ts'o */ 27985c1ff336SEric Whitney if (dirty_clusters && (free_clusters < 2 * dirty_clusters)) 279910ee27a0SMiao Xie try_to_writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE); 280000d4e736STheodore Ts'o 28015c1ff336SEric Whitney if (2 * free_clusters < 3 * dirty_clusters || 28025c1ff336SEric Whitney free_clusters < (dirty_clusters + EXT4_FREECLUSTERS_WATERMARK)) { 280379f0be8dSAneesh Kumar K.V /* 2804c8afb446SEric Sandeen * free block count is less than 150% of dirty blocks 2805c8afb446SEric Sandeen * or free blocks is less than watermark 280679f0be8dSAneesh Kumar K.V */ 280779f0be8dSAneesh Kumar K.V return 1; 280879f0be8dSAneesh Kumar K.V } 280979f0be8dSAneesh Kumar K.V return 0; 281079f0be8dSAneesh Kumar K.V } 281179f0be8dSAneesh Kumar K.V 28120ff8947fSEric Sandeen /* We always reserve for an inode update; the superblock could be there too */ 28130ff8947fSEric Sandeen static int ext4_da_write_credits(struct inode *inode, loff_t pos, unsigned len) 28140ff8947fSEric Sandeen { 2815e2b911c5SDarrick J. Wong if (likely(ext4_has_feature_large_file(inode->i_sb))) 28160ff8947fSEric Sandeen return 1; 28170ff8947fSEric Sandeen 28180ff8947fSEric Sandeen if (pos + len <= 0x7fffffffULL) 28190ff8947fSEric Sandeen return 1; 28200ff8947fSEric Sandeen 28210ff8947fSEric Sandeen /* We might need to update the superblock to set LARGE_FILE */ 28220ff8947fSEric Sandeen return 2; 28230ff8947fSEric Sandeen } 28240ff8947fSEric Sandeen 282564769240SAlex Tomas static int ext4_da_write_begin(struct file *file, struct address_space *mapping, 282664769240SAlex Tomas loff_t pos, unsigned len, unsigned flags, 282764769240SAlex Tomas struct page **pagep, void **fsdata) 282864769240SAlex Tomas { 282972b8ab9dSEric Sandeen int ret, retries = 0; 283064769240SAlex Tomas struct page *page; 283164769240SAlex Tomas pgoff_t index; 283264769240SAlex Tomas struct inode *inode = mapping->host; 283364769240SAlex Tomas handle_t *handle; 283464769240SAlex Tomas 283564769240SAlex Tomas index = pos >> PAGE_CACHE_SHIFT; 283679f0be8dSAneesh Kumar K.V 283779f0be8dSAneesh Kumar K.V if (ext4_nonda_switch(inode->i_sb)) { 283879f0be8dSAneesh Kumar K.V *fsdata = (void *)FALL_BACK_TO_NONDELALLOC; 283979f0be8dSAneesh Kumar K.V return ext4_write_begin(file, mapping, pos, 284079f0be8dSAneesh Kumar K.V len, flags, pagep, fsdata); 284179f0be8dSAneesh Kumar K.V } 284279f0be8dSAneesh Kumar K.V *fsdata = (void *)0; 28439bffad1eSTheodore Ts'o trace_ext4_da_write_begin(inode, pos, len, flags); 28449c3569b5STao Ma 28459c3569b5STao Ma if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) { 28469c3569b5STao Ma ret = ext4_da_write_inline_data_begin(mapping, inode, 28479c3569b5STao Ma pos, len, flags, 28489c3569b5STao Ma pagep, fsdata); 28499c3569b5STao Ma if (ret < 0) 285047564bfbSTheodore Ts'o return ret; 285147564bfbSTheodore Ts'o if (ret == 1) 285247564bfbSTheodore Ts'o return 0; 28539c3569b5STao Ma } 28549c3569b5STao Ma 285547564bfbSTheodore Ts'o /* 285647564bfbSTheodore Ts'o * grab_cache_page_write_begin() can take a long time if the 285747564bfbSTheodore Ts'o * system is thrashing due to memory pressure, or if the page 285847564bfbSTheodore Ts'o * is being written back. So grab it first before we start 285947564bfbSTheodore Ts'o * the transaction handle. This also allows us to allocate 286047564bfbSTheodore Ts'o * the page (if needed) without using GFP_NOFS. 286147564bfbSTheodore Ts'o */ 286247564bfbSTheodore Ts'o retry_grab: 286347564bfbSTheodore Ts'o page = grab_cache_page_write_begin(mapping, index, flags); 286447564bfbSTheodore Ts'o if (!page) 286547564bfbSTheodore Ts'o return -ENOMEM; 286647564bfbSTheodore Ts'o unlock_page(page); 286747564bfbSTheodore Ts'o 286864769240SAlex Tomas /* 286964769240SAlex Tomas * With delayed allocation, we don't log the i_disksize update 287064769240SAlex Tomas * if there is delayed block allocation. But we still need 287164769240SAlex Tomas * to journalling the i_disksize update if writes to the end 287264769240SAlex Tomas * of file which has an already mapped buffer. 287364769240SAlex Tomas */ 287447564bfbSTheodore Ts'o retry_journal: 28750ff8947fSEric Sandeen handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 28760ff8947fSEric Sandeen ext4_da_write_credits(inode, pos, len)); 287764769240SAlex Tomas if (IS_ERR(handle)) { 287847564bfbSTheodore Ts'o page_cache_release(page); 287947564bfbSTheodore Ts'o return PTR_ERR(handle); 288064769240SAlex Tomas } 288164769240SAlex Tomas 288247564bfbSTheodore Ts'o lock_page(page); 288347564bfbSTheodore Ts'o if (page->mapping != mapping) { 288447564bfbSTheodore Ts'o /* The page got truncated from under us */ 288547564bfbSTheodore Ts'o unlock_page(page); 288647564bfbSTheodore Ts'o page_cache_release(page); 2887d5a0d4f7SEric Sandeen ext4_journal_stop(handle); 288847564bfbSTheodore Ts'o goto retry_grab; 2889d5a0d4f7SEric Sandeen } 289047564bfbSTheodore Ts'o /* In case writeback began while the page was unlocked */ 28917afe5aa5SDmitry Monakhov wait_for_stable_page(page); 289264769240SAlex Tomas 28932058f83aSMichael Halcrow #ifdef CONFIG_EXT4_FS_ENCRYPTION 28942058f83aSMichael Halcrow ret = ext4_block_write_begin(page, pos, len, 28952058f83aSMichael Halcrow ext4_da_get_block_prep); 28962058f83aSMichael Halcrow #else 28976e1db88dSChristoph Hellwig ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep); 28982058f83aSMichael Halcrow #endif 289964769240SAlex Tomas if (ret < 0) { 290064769240SAlex Tomas unlock_page(page); 290164769240SAlex Tomas ext4_journal_stop(handle); 2902ae4d5372SAneesh Kumar K.V /* 2903ae4d5372SAneesh Kumar K.V * block_write_begin may have instantiated a few blocks 2904ae4d5372SAneesh Kumar K.V * outside i_size. Trim these off again. Don't need 2905ae4d5372SAneesh Kumar K.V * i_size_read because we hold i_mutex. 2906ae4d5372SAneesh Kumar K.V */ 2907ae4d5372SAneesh Kumar K.V if (pos + len > inode->i_size) 2908b9a4207dSJan Kara ext4_truncate_failed_write(inode); 290947564bfbSTheodore Ts'o 291047564bfbSTheodore Ts'o if (ret == -ENOSPC && 291147564bfbSTheodore Ts'o ext4_should_retry_alloc(inode->i_sb, &retries)) 291247564bfbSTheodore Ts'o goto retry_journal; 291347564bfbSTheodore Ts'o 291447564bfbSTheodore Ts'o page_cache_release(page); 291547564bfbSTheodore Ts'o return ret; 291664769240SAlex Tomas } 291764769240SAlex Tomas 291847564bfbSTheodore Ts'o *pagep = page; 291964769240SAlex Tomas return ret; 292064769240SAlex Tomas } 292164769240SAlex Tomas 2922632eaeabSMingming Cao /* 2923632eaeabSMingming Cao * Check if we should update i_disksize 2924632eaeabSMingming Cao * when write to the end of file but not require block allocation 2925632eaeabSMingming Cao */ 2926632eaeabSMingming Cao static int ext4_da_should_update_i_disksize(struct page *page, 2927632eaeabSMingming Cao unsigned long offset) 2928632eaeabSMingming Cao { 2929632eaeabSMingming Cao struct buffer_head *bh; 2930632eaeabSMingming Cao struct inode *inode = page->mapping->host; 2931632eaeabSMingming Cao unsigned int idx; 2932632eaeabSMingming Cao int i; 2933632eaeabSMingming Cao 2934632eaeabSMingming Cao bh = page_buffers(page); 2935632eaeabSMingming Cao idx = offset >> inode->i_blkbits; 2936632eaeabSMingming Cao 2937632eaeabSMingming Cao for (i = 0; i < idx; i++) 2938632eaeabSMingming Cao bh = bh->b_this_page; 2939632eaeabSMingming Cao 294029fa89d0SAneesh Kumar K.V if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh)) 2941632eaeabSMingming Cao return 0; 2942632eaeabSMingming Cao return 1; 2943632eaeabSMingming Cao } 2944632eaeabSMingming Cao 294564769240SAlex Tomas static int ext4_da_write_end(struct file *file, 294664769240SAlex Tomas struct address_space *mapping, 294764769240SAlex Tomas loff_t pos, unsigned len, unsigned copied, 294864769240SAlex Tomas struct page *page, void *fsdata) 294964769240SAlex Tomas { 295064769240SAlex Tomas struct inode *inode = mapping->host; 295164769240SAlex Tomas int ret = 0, ret2; 295264769240SAlex Tomas handle_t *handle = ext4_journal_current_handle(); 295364769240SAlex Tomas loff_t new_i_size; 2954632eaeabSMingming Cao unsigned long start, end; 295579f0be8dSAneesh Kumar K.V int write_mode = (int)(unsigned long)fsdata; 295679f0be8dSAneesh Kumar K.V 295774d553aaSTheodore Ts'o if (write_mode == FALL_BACK_TO_NONDELALLOC) 295874d553aaSTheodore Ts'o return ext4_write_end(file, mapping, pos, 295979f0be8dSAneesh Kumar K.V len, copied, page, fsdata); 2960632eaeabSMingming Cao 29619bffad1eSTheodore Ts'o trace_ext4_da_write_end(inode, pos, len, copied); 2962632eaeabSMingming Cao start = pos & (PAGE_CACHE_SIZE - 1); 2963632eaeabSMingming Cao end = start + copied - 1; 296464769240SAlex Tomas 296564769240SAlex Tomas /* 296664769240SAlex Tomas * generic_write_end() will run mark_inode_dirty() if i_size 296764769240SAlex Tomas * changes. So let's piggyback the i_disksize mark_inode_dirty 296864769240SAlex Tomas * into that. 296964769240SAlex Tomas */ 297064769240SAlex Tomas new_i_size = pos + copied; 2971ea51d132SAndrea Arcangeli if (copied && new_i_size > EXT4_I(inode)->i_disksize) { 29729c3569b5STao Ma if (ext4_has_inline_data(inode) || 29739c3569b5STao Ma ext4_da_should_update_i_disksize(page, end)) { 2974ee124d27SDmitry Monakhov ext4_update_i_disksize(inode, new_i_size); 2975cf17fea6SAneesh Kumar K.V /* We need to mark inode dirty even if 2976cf17fea6SAneesh Kumar K.V * new_i_size is less that inode->i_size 2977cf17fea6SAneesh Kumar K.V * bu greater than i_disksize.(hint delalloc) 2978cf17fea6SAneesh Kumar K.V */ 2979cf17fea6SAneesh Kumar K.V ext4_mark_inode_dirty(handle, inode); 2980632eaeabSMingming Cao } 2981632eaeabSMingming Cao } 29829c3569b5STao Ma 29839c3569b5STao Ma if (write_mode != CONVERT_INLINE_DATA && 29849c3569b5STao Ma ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA) && 29859c3569b5STao Ma ext4_has_inline_data(inode)) 29869c3569b5STao Ma ret2 = ext4_da_write_inline_data_end(inode, pos, len, copied, 29879c3569b5STao Ma page); 29889c3569b5STao Ma else 298964769240SAlex Tomas ret2 = generic_write_end(file, mapping, pos, len, copied, 299064769240SAlex Tomas page, fsdata); 29919c3569b5STao Ma 299264769240SAlex Tomas copied = ret2; 299364769240SAlex Tomas if (ret2 < 0) 299464769240SAlex Tomas ret = ret2; 299564769240SAlex Tomas ret2 = ext4_journal_stop(handle); 299664769240SAlex Tomas if (!ret) 299764769240SAlex Tomas ret = ret2; 299864769240SAlex Tomas 299964769240SAlex Tomas return ret ? ret : copied; 300064769240SAlex Tomas } 300164769240SAlex Tomas 3002d47992f8SLukas Czerner static void ext4_da_invalidatepage(struct page *page, unsigned int offset, 3003d47992f8SLukas Czerner unsigned int length) 300464769240SAlex Tomas { 300564769240SAlex Tomas /* 300664769240SAlex Tomas * Drop reserved blocks 300764769240SAlex Tomas */ 300864769240SAlex Tomas BUG_ON(!PageLocked(page)); 300964769240SAlex Tomas if (!page_has_buffers(page)) 301064769240SAlex Tomas goto out; 301164769240SAlex Tomas 3012ca99fdd2SLukas Czerner ext4_da_page_release_reservation(page, offset, length); 301364769240SAlex Tomas 301464769240SAlex Tomas out: 3015d47992f8SLukas Czerner ext4_invalidatepage(page, offset, length); 301664769240SAlex Tomas 301764769240SAlex Tomas return; 301864769240SAlex Tomas } 301964769240SAlex Tomas 3020ccd2506bSTheodore Ts'o /* 3021ccd2506bSTheodore Ts'o * Force all delayed allocation blocks to be allocated for a given inode. 3022ccd2506bSTheodore Ts'o */ 3023ccd2506bSTheodore Ts'o int ext4_alloc_da_blocks(struct inode *inode) 3024ccd2506bSTheodore Ts'o { 3025fb40ba0dSTheodore Ts'o trace_ext4_alloc_da_blocks(inode); 3026fb40ba0dSTheodore Ts'o 302771d4f7d0STheodore Ts'o if (!EXT4_I(inode)->i_reserved_data_blocks) 3028ccd2506bSTheodore Ts'o return 0; 3029ccd2506bSTheodore Ts'o 3030ccd2506bSTheodore Ts'o /* 3031ccd2506bSTheodore Ts'o * We do something simple for now. The filemap_flush() will 3032ccd2506bSTheodore Ts'o * also start triggering a write of the data blocks, which is 3033ccd2506bSTheodore Ts'o * not strictly speaking necessary (and for users of 3034ccd2506bSTheodore Ts'o * laptop_mode, not even desirable). However, to do otherwise 3035ccd2506bSTheodore Ts'o * would require replicating code paths in: 3036ccd2506bSTheodore Ts'o * 303720970ba6STheodore Ts'o * ext4_writepages() -> 3038ccd2506bSTheodore Ts'o * write_cache_pages() ---> (via passed in callback function) 3039ccd2506bSTheodore Ts'o * __mpage_da_writepage() --> 3040ccd2506bSTheodore Ts'o * mpage_add_bh_to_extent() 3041ccd2506bSTheodore Ts'o * mpage_da_map_blocks() 3042ccd2506bSTheodore Ts'o * 3043ccd2506bSTheodore Ts'o * The problem is that write_cache_pages(), located in 3044ccd2506bSTheodore Ts'o * mm/page-writeback.c, marks pages clean in preparation for 3045ccd2506bSTheodore Ts'o * doing I/O, which is not desirable if we're not planning on 3046ccd2506bSTheodore Ts'o * doing I/O at all. 3047ccd2506bSTheodore Ts'o * 3048ccd2506bSTheodore Ts'o * We could call write_cache_pages(), and then redirty all of 3049380cf090SWu Fengguang * the pages by calling redirty_page_for_writepage() but that 3050ccd2506bSTheodore Ts'o * would be ugly in the extreme. So instead we would need to 3051ccd2506bSTheodore Ts'o * replicate parts of the code in the above functions, 305225985edcSLucas De Marchi * simplifying them because we wouldn't actually intend to 3053ccd2506bSTheodore Ts'o * write out the pages, but rather only collect contiguous 3054ccd2506bSTheodore Ts'o * logical block extents, call the multi-block allocator, and 3055ccd2506bSTheodore Ts'o * then update the buffer heads with the block allocations. 3056ccd2506bSTheodore Ts'o * 3057ccd2506bSTheodore Ts'o * For now, though, we'll cheat by calling filemap_flush(), 3058ccd2506bSTheodore Ts'o * which will map the blocks, and start the I/O, but not 3059ccd2506bSTheodore Ts'o * actually wait for the I/O to complete. 3060ccd2506bSTheodore Ts'o */ 3061ccd2506bSTheodore Ts'o return filemap_flush(inode->i_mapping); 3062ccd2506bSTheodore Ts'o } 306364769240SAlex Tomas 306464769240SAlex Tomas /* 3065ac27a0ecSDave Kleikamp * bmap() is special. It gets used by applications such as lilo and by 3066ac27a0ecSDave Kleikamp * the swapper to find the on-disk block of a specific piece of data. 3067ac27a0ecSDave Kleikamp * 3068ac27a0ecSDave Kleikamp * Naturally, this is dangerous if the block concerned is still in the 3069617ba13bSMingming Cao * journal. If somebody makes a swapfile on an ext4 data-journaling 3070ac27a0ecSDave Kleikamp * filesystem and enables swap, then they may get a nasty shock when the 3071ac27a0ecSDave Kleikamp * data getting swapped to that swapfile suddenly gets overwritten by 3072ac27a0ecSDave Kleikamp * the original zero's written out previously to the journal and 3073ac27a0ecSDave Kleikamp * awaiting writeback in the kernel's buffer cache. 3074ac27a0ecSDave Kleikamp * 3075ac27a0ecSDave Kleikamp * So, if we see any bmap calls here on a modified, data-journaled file, 3076ac27a0ecSDave Kleikamp * take extra steps to flush any blocks which might be in the cache. 3077ac27a0ecSDave Kleikamp */ 3078617ba13bSMingming Cao static sector_t ext4_bmap(struct address_space *mapping, sector_t block) 3079ac27a0ecSDave Kleikamp { 3080ac27a0ecSDave Kleikamp struct inode *inode = mapping->host; 3081ac27a0ecSDave Kleikamp journal_t *journal; 3082ac27a0ecSDave Kleikamp int err; 3083ac27a0ecSDave Kleikamp 308446c7f254STao Ma /* 308546c7f254STao Ma * We can get here for an inline file via the FIBMAP ioctl 308646c7f254STao Ma */ 308746c7f254STao Ma if (ext4_has_inline_data(inode)) 308846c7f254STao Ma return 0; 308946c7f254STao Ma 309064769240SAlex Tomas if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) && 309164769240SAlex Tomas test_opt(inode->i_sb, DELALLOC)) { 309264769240SAlex Tomas /* 309364769240SAlex Tomas * With delalloc we want to sync the file 309464769240SAlex Tomas * so that we can make sure we allocate 309564769240SAlex Tomas * blocks for file 309664769240SAlex Tomas */ 309764769240SAlex Tomas filemap_write_and_wait(mapping); 309864769240SAlex Tomas } 309964769240SAlex Tomas 310019f5fb7aSTheodore Ts'o if (EXT4_JOURNAL(inode) && 310119f5fb7aSTheodore Ts'o ext4_test_inode_state(inode, EXT4_STATE_JDATA)) { 3102ac27a0ecSDave Kleikamp /* 3103ac27a0ecSDave Kleikamp * This is a REALLY heavyweight approach, but the use of 3104ac27a0ecSDave Kleikamp * bmap on dirty files is expected to be extremely rare: 3105ac27a0ecSDave Kleikamp * only if we run lilo or swapon on a freshly made file 3106ac27a0ecSDave Kleikamp * do we expect this to happen. 3107ac27a0ecSDave Kleikamp * 3108ac27a0ecSDave Kleikamp * (bmap requires CAP_SYS_RAWIO so this does not 3109ac27a0ecSDave Kleikamp * represent an unprivileged user DOS attack --- we'd be 3110ac27a0ecSDave Kleikamp * in trouble if mortal users could trigger this path at 3111ac27a0ecSDave Kleikamp * will.) 3112ac27a0ecSDave Kleikamp * 3113617ba13bSMingming Cao * NB. EXT4_STATE_JDATA is not set on files other than 3114ac27a0ecSDave Kleikamp * regular files. If somebody wants to bmap a directory 3115ac27a0ecSDave Kleikamp * or symlink and gets confused because the buffer 3116ac27a0ecSDave Kleikamp * hasn't yet been flushed to disk, they deserve 3117ac27a0ecSDave Kleikamp * everything they get. 3118ac27a0ecSDave Kleikamp */ 3119ac27a0ecSDave Kleikamp 312019f5fb7aSTheodore Ts'o ext4_clear_inode_state(inode, EXT4_STATE_JDATA); 3121617ba13bSMingming Cao journal = EXT4_JOURNAL(inode); 3122dab291afSMingming Cao jbd2_journal_lock_updates(journal); 3123dab291afSMingming Cao err = jbd2_journal_flush(journal); 3124dab291afSMingming Cao jbd2_journal_unlock_updates(journal); 3125ac27a0ecSDave Kleikamp 3126ac27a0ecSDave Kleikamp if (err) 3127ac27a0ecSDave Kleikamp return 0; 3128ac27a0ecSDave Kleikamp } 3129ac27a0ecSDave Kleikamp 3130617ba13bSMingming Cao return generic_block_bmap(mapping, block, ext4_get_block); 3131ac27a0ecSDave Kleikamp } 3132ac27a0ecSDave Kleikamp 3133617ba13bSMingming Cao static int ext4_readpage(struct file *file, struct page *page) 3134ac27a0ecSDave Kleikamp { 313546c7f254STao Ma int ret = -EAGAIN; 313646c7f254STao Ma struct inode *inode = page->mapping->host; 313746c7f254STao Ma 31380562e0baSJiaying Zhang trace_ext4_readpage(page); 313946c7f254STao Ma 314046c7f254STao Ma if (ext4_has_inline_data(inode)) 314146c7f254STao Ma ret = ext4_readpage_inline(inode, page); 314246c7f254STao Ma 314346c7f254STao Ma if (ret == -EAGAIN) 3144f64e02feSTheodore Ts'o return ext4_mpage_readpages(page->mapping, NULL, page, 1); 314546c7f254STao Ma 314646c7f254STao Ma return ret; 3147ac27a0ecSDave Kleikamp } 3148ac27a0ecSDave Kleikamp 3149ac27a0ecSDave Kleikamp static int 3150617ba13bSMingming Cao ext4_readpages(struct file *file, struct address_space *mapping, 3151ac27a0ecSDave Kleikamp struct list_head *pages, unsigned nr_pages) 3152ac27a0ecSDave Kleikamp { 315346c7f254STao Ma struct inode *inode = mapping->host; 315446c7f254STao Ma 315546c7f254STao Ma /* If the file has inline data, no need to do readpages. */ 315646c7f254STao Ma if (ext4_has_inline_data(inode)) 315746c7f254STao Ma return 0; 315846c7f254STao Ma 3159f64e02feSTheodore Ts'o return ext4_mpage_readpages(mapping, pages, NULL, nr_pages); 3160ac27a0ecSDave Kleikamp } 3161ac27a0ecSDave Kleikamp 3162d47992f8SLukas Czerner static void ext4_invalidatepage(struct page *page, unsigned int offset, 3163d47992f8SLukas Czerner unsigned int length) 3164ac27a0ecSDave Kleikamp { 3165ca99fdd2SLukas Czerner trace_ext4_invalidatepage(page, offset, length); 31660562e0baSJiaying Zhang 31674520fb3cSJan Kara /* No journalling happens on data buffers when this function is used */ 31684520fb3cSJan Kara WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page))); 31694520fb3cSJan Kara 3170ca99fdd2SLukas Czerner block_invalidatepage(page, offset, length); 31714520fb3cSJan Kara } 31724520fb3cSJan Kara 317353e87268SJan Kara static int __ext4_journalled_invalidatepage(struct page *page, 3174ca99fdd2SLukas Czerner unsigned int offset, 3175ca99fdd2SLukas Czerner unsigned int length) 31764520fb3cSJan Kara { 31774520fb3cSJan Kara journal_t *journal = EXT4_JOURNAL(page->mapping->host); 31784520fb3cSJan Kara 3179ca99fdd2SLukas Czerner trace_ext4_journalled_invalidatepage(page, offset, length); 31804520fb3cSJan Kara 3181744692dcSJiaying Zhang /* 3182ac27a0ecSDave Kleikamp * If it's a full truncate we just forget about the pending dirtying 3183ac27a0ecSDave Kleikamp */ 3184ca99fdd2SLukas Czerner if (offset == 0 && length == PAGE_CACHE_SIZE) 3185ac27a0ecSDave Kleikamp ClearPageChecked(page); 3186ac27a0ecSDave Kleikamp 3187ca99fdd2SLukas Czerner return jbd2_journal_invalidatepage(journal, page, offset, length); 318853e87268SJan Kara } 318953e87268SJan Kara 319053e87268SJan Kara /* Wrapper for aops... */ 319153e87268SJan Kara static void ext4_journalled_invalidatepage(struct page *page, 3192d47992f8SLukas Czerner unsigned int offset, 3193d47992f8SLukas Czerner unsigned int length) 319453e87268SJan Kara { 3195ca99fdd2SLukas Czerner WARN_ON(__ext4_journalled_invalidatepage(page, offset, length) < 0); 3196ac27a0ecSDave Kleikamp } 3197ac27a0ecSDave Kleikamp 3198617ba13bSMingming Cao static int ext4_releasepage(struct page *page, gfp_t wait) 3199ac27a0ecSDave Kleikamp { 3200617ba13bSMingming Cao journal_t *journal = EXT4_JOURNAL(page->mapping->host); 3201ac27a0ecSDave Kleikamp 32020562e0baSJiaying Zhang trace_ext4_releasepage(page); 32030562e0baSJiaying Zhang 3204e1c36595SJan Kara /* Page has dirty journalled data -> cannot release */ 3205e1c36595SJan Kara if (PageChecked(page)) 3206ac27a0ecSDave Kleikamp return 0; 32070390131bSFrank Mayhar if (journal) 3208dab291afSMingming Cao return jbd2_journal_try_to_free_buffers(journal, page, wait); 32090390131bSFrank Mayhar else 32100390131bSFrank Mayhar return try_to_free_buffers(page); 3211ac27a0ecSDave Kleikamp } 3212ac27a0ecSDave Kleikamp 3213ba5843f5SJan Kara #ifdef CONFIG_FS_DAX 3214ba5843f5SJan Kara int ext4_dax_mmap_get_block(struct inode *inode, sector_t iblock, 3215ed923b57SMatthew Wilcox struct buffer_head *bh_result, int create) 3216ed923b57SMatthew Wilcox { 3217ba5843f5SJan Kara int ret, err; 3218ba5843f5SJan Kara int credits; 3219ba5843f5SJan Kara struct ext4_map_blocks map; 3220ba5843f5SJan Kara handle_t *handle = NULL; 3221ba5843f5SJan Kara int flags = 0; 3222c86d8db3SJan Kara 3223ba5843f5SJan Kara ext4_debug("ext4_dax_mmap_get_block: inode %lu, create flag %d\n", 3224ed923b57SMatthew Wilcox inode->i_ino, create); 3225ba5843f5SJan Kara map.m_lblk = iblock; 3226ba5843f5SJan Kara map.m_len = bh_result->b_size >> inode->i_blkbits; 3227ba5843f5SJan Kara credits = ext4_chunk_trans_blocks(inode, map.m_len); 3228ba5843f5SJan Kara if (create) { 3229ba5843f5SJan Kara flags |= EXT4_GET_BLOCKS_PRE_IO | EXT4_GET_BLOCKS_CREATE_ZERO; 3230ba5843f5SJan Kara handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, credits); 3231ba5843f5SJan Kara if (IS_ERR(handle)) { 3232ba5843f5SJan Kara ret = PTR_ERR(handle); 3233ba5843f5SJan Kara return ret; 3234ed923b57SMatthew Wilcox } 3235ba5843f5SJan Kara } 3236ba5843f5SJan Kara 3237ba5843f5SJan Kara ret = ext4_map_blocks(handle, inode, &map, flags); 3238ba5843f5SJan Kara if (create) { 3239ba5843f5SJan Kara err = ext4_journal_stop(handle); 3240ba5843f5SJan Kara if (ret >= 0 && err < 0) 3241ba5843f5SJan Kara ret = err; 3242ba5843f5SJan Kara } 3243ba5843f5SJan Kara if (ret <= 0) 3244ba5843f5SJan Kara goto out; 3245ba5843f5SJan Kara if (map.m_flags & EXT4_MAP_UNWRITTEN) { 3246ba5843f5SJan Kara int err2; 3247ba5843f5SJan Kara 3248ba5843f5SJan Kara /* 3249ba5843f5SJan Kara * We are protected by i_mmap_sem so we know block cannot go 3250ba5843f5SJan Kara * away from under us even though we dropped i_data_sem. 3251ba5843f5SJan Kara * Convert extent to written and write zeros there. 3252ba5843f5SJan Kara * 3253ba5843f5SJan Kara * Note: We may get here even when create == 0. 3254ba5843f5SJan Kara */ 3255ba5843f5SJan Kara handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, credits); 3256ba5843f5SJan Kara if (IS_ERR(handle)) { 3257ba5843f5SJan Kara ret = PTR_ERR(handle); 3258ba5843f5SJan Kara goto out; 3259ba5843f5SJan Kara } 3260ba5843f5SJan Kara 3261ba5843f5SJan Kara err = ext4_map_blocks(handle, inode, &map, 3262ba5843f5SJan Kara EXT4_GET_BLOCKS_CONVERT | EXT4_GET_BLOCKS_CREATE_ZERO); 3263ba5843f5SJan Kara if (err < 0) 3264ba5843f5SJan Kara ret = err; 3265ba5843f5SJan Kara err2 = ext4_journal_stop(handle); 3266ba5843f5SJan Kara if (err2 < 0 && ret > 0) 3267ba5843f5SJan Kara ret = err2; 3268ba5843f5SJan Kara } 3269ba5843f5SJan Kara out: 3270ba5843f5SJan Kara WARN_ON_ONCE(ret == 0 && create); 3271ba5843f5SJan Kara if (ret > 0) { 3272ba5843f5SJan Kara map_bh(bh_result, inode->i_sb, map.m_pblk); 3273ba5843f5SJan Kara bh_result->b_state = (bh_result->b_state & ~EXT4_MAP_FLAGS) | 3274ba5843f5SJan Kara map.m_flags; 3275ba5843f5SJan Kara /* 3276ba5843f5SJan Kara * At least for now we have to clear BH_New so that DAX code 3277ba5843f5SJan Kara * doesn't attempt to zero blocks again in a racy way. 3278ba5843f5SJan Kara */ 3279ba5843f5SJan Kara bh_result->b_state &= ~(1 << BH_New); 3280ba5843f5SJan Kara bh_result->b_size = map.m_len << inode->i_blkbits; 3281ba5843f5SJan Kara ret = 0; 3282ba5843f5SJan Kara } 3283ba5843f5SJan Kara return ret; 3284ba5843f5SJan Kara } 3285ba5843f5SJan Kara #endif 3286ed923b57SMatthew Wilcox 32874c0425ffSMingming Cao static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset, 32887b7a8665SChristoph Hellwig ssize_t size, void *private) 32894c0425ffSMingming Cao { 3290*109811c2SJan Kara ext4_io_end_t *io_end = private; 32914c0425ffSMingming Cao 329297a851edSJan Kara /* if not async direct IO just return */ 32937b7a8665SChristoph Hellwig if (!io_end) 329497a851edSJan Kara return; 32954b70df18SMingming 32968d5d02e6SMingming Cao ext_debug("ext4_end_io_dio(): io_end 0x%p " 3297ace36ad4SJoe Perches "for inode %lu, iocb 0x%p, offset %llu, size %zd\n", 3298*109811c2SJan Kara io_end, io_end->inode->i_ino, iocb, offset, size); 32998d5d02e6SMingming Cao 33004c0425ffSMingming Cao io_end->offset = offset; 33014c0425ffSMingming Cao io_end->size = size; 33027b7a8665SChristoph Hellwig ext4_put_io_end(io_end); 33034c0425ffSMingming Cao } 3304c7064ef1SJiaying Zhang 33054c0425ffSMingming Cao /* 33064c0425ffSMingming Cao * For ext4 extent files, ext4 will do direct-io write to holes, 33074c0425ffSMingming Cao * preallocated extents, and those write extend the file, no need to 33084c0425ffSMingming Cao * fall back to buffered IO. 33094c0425ffSMingming Cao * 3310556615dcSLukas Czerner * For holes, we fallocate those blocks, mark them as unwritten 331169c499d1STheodore Ts'o * If those blocks were preallocated, we mark sure they are split, but 3312556615dcSLukas Czerner * still keep the range to write as unwritten. 33134c0425ffSMingming Cao * 331469c499d1STheodore Ts'o * The unwritten extents will be converted to written when DIO is completed. 33158d5d02e6SMingming Cao * For async direct IO, since the IO may still pending when return, we 331625985edcSLucas De Marchi * set up an end_io call back function, which will do the conversion 33178d5d02e6SMingming Cao * when async direct IO completed. 33184c0425ffSMingming Cao * 33194c0425ffSMingming Cao * If the O_DIRECT write will extend the file then add this inode to the 33204c0425ffSMingming Cao * orphan list. So recovery will truncate it back to the original size 33214c0425ffSMingming Cao * if the machine crashes during the write. 33224c0425ffSMingming Cao * 33234c0425ffSMingming Cao */ 33246f673763SOmar Sandoval static ssize_t ext4_ext_direct_IO(struct kiocb *iocb, struct iov_iter *iter, 33256f673763SOmar Sandoval loff_t offset) 33264c0425ffSMingming Cao { 33274c0425ffSMingming Cao struct file *file = iocb->ki_filp; 33284c0425ffSMingming Cao struct inode *inode = file->f_mapping->host; 33294c0425ffSMingming Cao ssize_t ret; 3330a6cbcd4aSAl Viro size_t count = iov_iter_count(iter); 3331729f52c6SZheng Liu int overwrite = 0; 33328b0f165fSAnatol Pomozov get_block_t *get_block_func = NULL; 33338b0f165fSAnatol Pomozov int dio_flags = 0; 333469c499d1STheodore Ts'o loff_t final_size = offset + count; 333569c499d1STheodore Ts'o 333669c499d1STheodore Ts'o /* Use the old path for reads and writes beyond i_size. */ 33376f673763SOmar Sandoval if (iov_iter_rw(iter) != WRITE || final_size > inode->i_size) 33386f673763SOmar Sandoval return ext4_ind_direct_IO(iocb, iter, offset); 3339729f52c6SZheng Liu 33404bd809dbSZheng Liu BUG_ON(iocb->private == NULL); 33414bd809dbSZheng Liu 3342e8340395SJan Kara /* 3343e8340395SJan Kara * Make all waiters for direct IO properly wait also for extent 3344e8340395SJan Kara * conversion. This also disallows race between truncate() and 3345e8340395SJan Kara * overwrite DIO as i_dio_count needs to be incremented under i_mutex. 3346e8340395SJan Kara */ 33476f673763SOmar Sandoval if (iov_iter_rw(iter) == WRITE) 3348fe0f07d0SJens Axboe inode_dio_begin(inode); 3349e8340395SJan Kara 33504bd809dbSZheng Liu /* If we do a overwrite dio, i_mutex locking can be released */ 33514bd809dbSZheng Liu overwrite = *((int *)iocb->private); 33524bd809dbSZheng Liu 33532dcba478SJan Kara if (overwrite) 33545955102cSAl Viro inode_unlock(inode); 33554bd809dbSZheng Liu 33564c0425ffSMingming Cao /* 33578d5d02e6SMingming Cao * We could direct write to holes and fallocate. 33588d5d02e6SMingming Cao * 3359*109811c2SJan Kara * Allocated blocks to fill the hole are marked as unwritten to prevent 3360*109811c2SJan Kara * parallel buffered read to expose the stale data before DIO complete 3361*109811c2SJan Kara * the data IO. 33628d5d02e6SMingming Cao * 3363*109811c2SJan Kara * As to previously fallocated extents, ext4 get_block will just simply 3364*109811c2SJan Kara * mark the buffer mapped but still keep the extents unwritten. 33654c0425ffSMingming Cao * 3366*109811c2SJan Kara * For non AIO case, we will convert those unwritten extents to written 3367*109811c2SJan Kara * after return back from blockdev_direct_IO. That way we save us from 3368*109811c2SJan Kara * allocating io_end structure and also the overhead of offloading 3369*109811c2SJan Kara * the extent convertion to a workqueue. 33704c0425ffSMingming Cao * 337169c499d1STheodore Ts'o * For async DIO, the conversion needs to be deferred when the 337269c499d1STheodore Ts'o * IO is completed. The ext4 end_io callback function will be 337369c499d1STheodore Ts'o * called to take care of the conversion work. Here for async 337469c499d1STheodore Ts'o * case, we allocate an io_end structure to hook to the iocb. 33754c0425ffSMingming Cao */ 33768d5d02e6SMingming Cao iocb->private = NULL; 3377*109811c2SJan Kara if (overwrite) 3378705965bdSJan Kara get_block_func = ext4_dio_get_block_overwrite; 3379*109811c2SJan Kara else if (is_sync_kiocb(iocb)) { 3380*109811c2SJan Kara get_block_func = ext4_dio_get_block_unwritten_sync; 3381*109811c2SJan Kara dio_flags = DIO_LOCKING; 338274dae427SJan Kara } else { 3383*109811c2SJan Kara get_block_func = ext4_dio_get_block_unwritten_async; 33848b0f165fSAnatol Pomozov dio_flags = DIO_LOCKING; 33858b0f165fSAnatol Pomozov } 33862058f83aSMichael Halcrow #ifdef CONFIG_EXT4_FS_ENCRYPTION 33872058f83aSMichael Halcrow BUG_ON(ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode)); 33882058f83aSMichael Halcrow #endif 3389923ae0ffSRoss Zwisler if (IS_DAX(inode)) 3390a95cd631SOmar Sandoval ret = dax_do_io(iocb, inode, iter, offset, get_block_func, 3391923ae0ffSRoss Zwisler ext4_end_io_dio, dio_flags); 3392923ae0ffSRoss Zwisler else 339317f8c842SOmar Sandoval ret = __blockdev_direct_IO(iocb, inode, 3394923ae0ffSRoss Zwisler inode->i_sb->s_bdev, iter, offset, 33958b0f165fSAnatol Pomozov get_block_func, 3396923ae0ffSRoss Zwisler ext4_end_io_dio, NULL, dio_flags); 33978b0f165fSAnatol Pomozov 339897a851edSJan Kara if (ret > 0 && !overwrite && ext4_test_inode_state(inode, 33995f524950SMingming EXT4_STATE_DIO_UNWRITTEN)) { 3400109f5565SMingming int err; 34018d5d02e6SMingming Cao /* 34028d5d02e6SMingming Cao * for non AIO case, since the IO is already 340325985edcSLucas De Marchi * completed, we could do the conversion right here 34048d5d02e6SMingming Cao */ 34056b523df4SJan Kara err = ext4_convert_unwritten_extents(NULL, inode, 34068d5d02e6SMingming Cao offset, ret); 3407109f5565SMingming if (err < 0) 3408109f5565SMingming ret = err; 340919f5fb7aSTheodore Ts'o ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN); 3410109f5565SMingming } 34114bd809dbSZheng Liu 34126f673763SOmar Sandoval if (iov_iter_rw(iter) == WRITE) 3413fe0f07d0SJens Axboe inode_dio_end(inode); 34144bd809dbSZheng Liu /* take i_mutex locking again if we do a ovewrite dio */ 34152dcba478SJan Kara if (overwrite) 34165955102cSAl Viro inode_lock(inode); 34174bd809dbSZheng Liu 34184c0425ffSMingming Cao return ret; 34194c0425ffSMingming Cao } 34208d5d02e6SMingming Cao 342122c6186eSOmar Sandoval static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter, 342222c6186eSOmar Sandoval loff_t offset) 34234c0425ffSMingming Cao { 34244c0425ffSMingming Cao struct file *file = iocb->ki_filp; 34254c0425ffSMingming Cao struct inode *inode = file->f_mapping->host; 3426a6cbcd4aSAl Viro size_t count = iov_iter_count(iter); 34270562e0baSJiaying Zhang ssize_t ret; 34284c0425ffSMingming Cao 34292058f83aSMichael Halcrow #ifdef CONFIG_EXT4_FS_ENCRYPTION 34302058f83aSMichael Halcrow if (ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode)) 34312058f83aSMichael Halcrow return 0; 34322058f83aSMichael Halcrow #endif 34332058f83aSMichael Halcrow 343484ebd795STheodore Ts'o /* 343584ebd795STheodore Ts'o * If we are doing data journalling we don't support O_DIRECT 343684ebd795STheodore Ts'o */ 343784ebd795STheodore Ts'o if (ext4_should_journal_data(inode)) 343884ebd795STheodore Ts'o return 0; 343984ebd795STheodore Ts'o 344046c7f254STao Ma /* Let buffer I/O handle the inline data case. */ 344146c7f254STao Ma if (ext4_has_inline_data(inode)) 344246c7f254STao Ma return 0; 344346c7f254STao Ma 34446f673763SOmar Sandoval trace_ext4_direct_IO_enter(inode, offset, count, iov_iter_rw(iter)); 344512e9b892SDmitry Monakhov if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) 34466f673763SOmar Sandoval ret = ext4_ext_direct_IO(iocb, iter, offset); 34470562e0baSJiaying Zhang else 34486f673763SOmar Sandoval ret = ext4_ind_direct_IO(iocb, iter, offset); 34496f673763SOmar Sandoval trace_ext4_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), ret); 34500562e0baSJiaying Zhang return ret; 34514c0425ffSMingming Cao } 34524c0425ffSMingming Cao 3453ac27a0ecSDave Kleikamp /* 3454617ba13bSMingming Cao * Pages can be marked dirty completely asynchronously from ext4's journalling 3455ac27a0ecSDave Kleikamp * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do 3456ac27a0ecSDave Kleikamp * much here because ->set_page_dirty is called under VFS locks. The page is 3457ac27a0ecSDave Kleikamp * not necessarily locked. 3458ac27a0ecSDave Kleikamp * 3459ac27a0ecSDave Kleikamp * We cannot just dirty the page and leave attached buffers clean, because the 3460ac27a0ecSDave Kleikamp * buffers' dirty state is "definitive". We cannot just set the buffers dirty 3461ac27a0ecSDave Kleikamp * or jbddirty because all the journalling code will explode. 3462ac27a0ecSDave Kleikamp * 3463ac27a0ecSDave Kleikamp * So what we do is to mark the page "pending dirty" and next time writepage 3464ac27a0ecSDave Kleikamp * is called, propagate that into the buffers appropriately. 3465ac27a0ecSDave Kleikamp */ 3466617ba13bSMingming Cao static int ext4_journalled_set_page_dirty(struct page *page) 3467ac27a0ecSDave Kleikamp { 3468ac27a0ecSDave Kleikamp SetPageChecked(page); 3469ac27a0ecSDave Kleikamp return __set_page_dirty_nobuffers(page); 3470ac27a0ecSDave Kleikamp } 3471ac27a0ecSDave Kleikamp 347274d553aaSTheodore Ts'o static const struct address_space_operations ext4_aops = { 3473617ba13bSMingming Cao .readpage = ext4_readpage, 3474617ba13bSMingming Cao .readpages = ext4_readpages, 347543ce1d23SAneesh Kumar K.V .writepage = ext4_writepage, 347620970ba6STheodore Ts'o .writepages = ext4_writepages, 3477bfc1af65SNick Piggin .write_begin = ext4_write_begin, 347874d553aaSTheodore Ts'o .write_end = ext4_write_end, 3479617ba13bSMingming Cao .bmap = ext4_bmap, 3480617ba13bSMingming Cao .invalidatepage = ext4_invalidatepage, 3481617ba13bSMingming Cao .releasepage = ext4_releasepage, 3482617ba13bSMingming Cao .direct_IO = ext4_direct_IO, 3483ac27a0ecSDave Kleikamp .migratepage = buffer_migrate_page, 34848ab22b9aSHisashi Hifumi .is_partially_uptodate = block_is_partially_uptodate, 3485aa261f54SAndi Kleen .error_remove_page = generic_error_remove_page, 3486ac27a0ecSDave Kleikamp }; 3487ac27a0ecSDave Kleikamp 3488617ba13bSMingming Cao static const struct address_space_operations ext4_journalled_aops = { 3489617ba13bSMingming Cao .readpage = ext4_readpage, 3490617ba13bSMingming Cao .readpages = ext4_readpages, 349143ce1d23SAneesh Kumar K.V .writepage = ext4_writepage, 349220970ba6STheodore Ts'o .writepages = ext4_writepages, 3493bfc1af65SNick Piggin .write_begin = ext4_write_begin, 3494bfc1af65SNick Piggin .write_end = ext4_journalled_write_end, 3495617ba13bSMingming Cao .set_page_dirty = ext4_journalled_set_page_dirty, 3496617ba13bSMingming Cao .bmap = ext4_bmap, 34974520fb3cSJan Kara .invalidatepage = ext4_journalled_invalidatepage, 3498617ba13bSMingming Cao .releasepage = ext4_releasepage, 349984ebd795STheodore Ts'o .direct_IO = ext4_direct_IO, 35008ab22b9aSHisashi Hifumi .is_partially_uptodate = block_is_partially_uptodate, 3501aa261f54SAndi Kleen .error_remove_page = generic_error_remove_page, 3502ac27a0ecSDave Kleikamp }; 3503ac27a0ecSDave Kleikamp 350464769240SAlex Tomas static const struct address_space_operations ext4_da_aops = { 350564769240SAlex Tomas .readpage = ext4_readpage, 350664769240SAlex Tomas .readpages = ext4_readpages, 350743ce1d23SAneesh Kumar K.V .writepage = ext4_writepage, 350820970ba6STheodore Ts'o .writepages = ext4_writepages, 350964769240SAlex Tomas .write_begin = ext4_da_write_begin, 351064769240SAlex Tomas .write_end = ext4_da_write_end, 351164769240SAlex Tomas .bmap = ext4_bmap, 351264769240SAlex Tomas .invalidatepage = ext4_da_invalidatepage, 351364769240SAlex Tomas .releasepage = ext4_releasepage, 351464769240SAlex Tomas .direct_IO = ext4_direct_IO, 351564769240SAlex Tomas .migratepage = buffer_migrate_page, 35168ab22b9aSHisashi Hifumi .is_partially_uptodate = block_is_partially_uptodate, 3517aa261f54SAndi Kleen .error_remove_page = generic_error_remove_page, 351864769240SAlex Tomas }; 351964769240SAlex Tomas 3520617ba13bSMingming Cao void ext4_set_aops(struct inode *inode) 3521ac27a0ecSDave Kleikamp { 35223d2b1582SLukas Czerner switch (ext4_inode_journal_mode(inode)) { 35233d2b1582SLukas Czerner case EXT4_INODE_ORDERED_DATA_MODE: 352474d553aaSTheodore Ts'o ext4_set_inode_state(inode, EXT4_STATE_ORDERED_MODE); 35253d2b1582SLukas Czerner break; 35263d2b1582SLukas Czerner case EXT4_INODE_WRITEBACK_DATA_MODE: 352774d553aaSTheodore Ts'o ext4_clear_inode_state(inode, EXT4_STATE_ORDERED_MODE); 35283d2b1582SLukas Czerner break; 35293d2b1582SLukas Czerner case EXT4_INODE_JOURNAL_DATA_MODE: 3530617ba13bSMingming Cao inode->i_mapping->a_ops = &ext4_journalled_aops; 353174d553aaSTheodore Ts'o return; 35323d2b1582SLukas Czerner default: 35333d2b1582SLukas Czerner BUG(); 35343d2b1582SLukas Czerner } 353574d553aaSTheodore Ts'o if (test_opt(inode->i_sb, DELALLOC)) 353674d553aaSTheodore Ts'o inode->i_mapping->a_ops = &ext4_da_aops; 353774d553aaSTheodore Ts'o else 353874d553aaSTheodore Ts'o inode->i_mapping->a_ops = &ext4_aops; 3539ac27a0ecSDave Kleikamp } 3540ac27a0ecSDave Kleikamp 3541923ae0ffSRoss Zwisler static int __ext4_block_zero_page_range(handle_t *handle, 3542d863dc36SLukas Czerner struct address_space *mapping, loff_t from, loff_t length) 3543d863dc36SLukas Czerner { 3544d863dc36SLukas Czerner ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT; 3545d863dc36SLukas Czerner unsigned offset = from & (PAGE_CACHE_SIZE-1); 3546923ae0ffSRoss Zwisler unsigned blocksize, pos; 3547d863dc36SLukas Czerner ext4_lblk_t iblock; 3548d863dc36SLukas Czerner struct inode *inode = mapping->host; 3549d863dc36SLukas Czerner struct buffer_head *bh; 3550d863dc36SLukas Czerner struct page *page; 3551d863dc36SLukas Czerner int err = 0; 3552d863dc36SLukas Czerner 3553d863dc36SLukas Czerner page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT, 3554c62d2555SMichal Hocko mapping_gfp_constraint(mapping, ~__GFP_FS)); 3555d863dc36SLukas Czerner if (!page) 3556d863dc36SLukas Czerner return -ENOMEM; 3557d863dc36SLukas Czerner 3558d863dc36SLukas Czerner blocksize = inode->i_sb->s_blocksize; 3559d863dc36SLukas Czerner 3560d863dc36SLukas Czerner iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits); 3561d863dc36SLukas Czerner 3562d863dc36SLukas Czerner if (!page_has_buffers(page)) 3563d863dc36SLukas Czerner create_empty_buffers(page, blocksize, 0); 3564d863dc36SLukas Czerner 3565d863dc36SLukas Czerner /* Find the buffer that contains "offset" */ 3566d863dc36SLukas Czerner bh = page_buffers(page); 3567d863dc36SLukas Czerner pos = blocksize; 3568d863dc36SLukas Czerner while (offset >= pos) { 3569d863dc36SLukas Czerner bh = bh->b_this_page; 3570d863dc36SLukas Czerner iblock++; 3571d863dc36SLukas Czerner pos += blocksize; 3572d863dc36SLukas Czerner } 3573d863dc36SLukas Czerner if (buffer_freed(bh)) { 3574d863dc36SLukas Czerner BUFFER_TRACE(bh, "freed: skip"); 3575d863dc36SLukas Czerner goto unlock; 3576d863dc36SLukas Czerner } 3577d863dc36SLukas Czerner if (!buffer_mapped(bh)) { 3578d863dc36SLukas Czerner BUFFER_TRACE(bh, "unmapped"); 3579d863dc36SLukas Czerner ext4_get_block(inode, iblock, bh, 0); 3580d863dc36SLukas Czerner /* unmapped? It's a hole - nothing to do */ 3581d863dc36SLukas Czerner if (!buffer_mapped(bh)) { 3582d863dc36SLukas Czerner BUFFER_TRACE(bh, "still unmapped"); 3583d863dc36SLukas Czerner goto unlock; 3584d863dc36SLukas Czerner } 3585d863dc36SLukas Czerner } 3586d863dc36SLukas Czerner 3587d863dc36SLukas Czerner /* Ok, it's mapped. Make sure it's up-to-date */ 3588d863dc36SLukas Czerner if (PageUptodate(page)) 3589d863dc36SLukas Czerner set_buffer_uptodate(bh); 3590d863dc36SLukas Czerner 3591d863dc36SLukas Czerner if (!buffer_uptodate(bh)) { 3592d863dc36SLukas Czerner err = -EIO; 3593d863dc36SLukas Czerner ll_rw_block(READ, 1, &bh); 3594d863dc36SLukas Czerner wait_on_buffer(bh); 3595d863dc36SLukas Czerner /* Uhhuh. Read error. Complain and punt. */ 3596d863dc36SLukas Czerner if (!buffer_uptodate(bh)) 3597d863dc36SLukas Czerner goto unlock; 3598c9c7429cSMichael Halcrow if (S_ISREG(inode->i_mode) && 3599c9c7429cSMichael Halcrow ext4_encrypted_inode(inode)) { 3600c9c7429cSMichael Halcrow /* We expect the key to be set. */ 3601c9c7429cSMichael Halcrow BUG_ON(!ext4_has_encryption_key(inode)); 3602c9c7429cSMichael Halcrow BUG_ON(blocksize != PAGE_CACHE_SIZE); 36033684de8cSTheodore Ts'o WARN_ON_ONCE(ext4_decrypt(page)); 3604c9c7429cSMichael Halcrow } 3605d863dc36SLukas Czerner } 3606d863dc36SLukas Czerner if (ext4_should_journal_data(inode)) { 3607d863dc36SLukas Czerner BUFFER_TRACE(bh, "get write access"); 3608d863dc36SLukas Czerner err = ext4_journal_get_write_access(handle, bh); 3609d863dc36SLukas Czerner if (err) 3610d863dc36SLukas Czerner goto unlock; 3611d863dc36SLukas Czerner } 3612d863dc36SLukas Czerner zero_user(page, offset, length); 3613d863dc36SLukas Czerner BUFFER_TRACE(bh, "zeroed end of block"); 3614d863dc36SLukas Czerner 3615d863dc36SLukas Czerner if (ext4_should_journal_data(inode)) { 3616d863dc36SLukas Czerner err = ext4_handle_dirty_metadata(handle, inode, bh); 36170713ed0cSLukas Czerner } else { 3618353eefd3Sjon ernst err = 0; 3619d863dc36SLukas Czerner mark_buffer_dirty(bh); 36200713ed0cSLukas Czerner if (ext4_test_inode_state(inode, EXT4_STATE_ORDERED_MODE)) 36210713ed0cSLukas Czerner err = ext4_jbd2_file_inode(handle, inode); 36220713ed0cSLukas Czerner } 3623d863dc36SLukas Czerner 3624d863dc36SLukas Czerner unlock: 3625d863dc36SLukas Czerner unlock_page(page); 3626d863dc36SLukas Czerner page_cache_release(page); 3627d863dc36SLukas Czerner return err; 3628d863dc36SLukas Czerner } 3629d863dc36SLukas Czerner 363094350ab5SMatthew Wilcox /* 3631923ae0ffSRoss Zwisler * ext4_block_zero_page_range() zeros out a mapping of length 'length' 3632923ae0ffSRoss Zwisler * starting from file offset 'from'. The range to be zero'd must 3633923ae0ffSRoss Zwisler * be contained with in one block. If the specified range exceeds 3634923ae0ffSRoss Zwisler * the end of the block it will be shortened to end of the block 3635923ae0ffSRoss Zwisler * that cooresponds to 'from' 3636923ae0ffSRoss Zwisler */ 3637923ae0ffSRoss Zwisler static int ext4_block_zero_page_range(handle_t *handle, 3638923ae0ffSRoss Zwisler struct address_space *mapping, loff_t from, loff_t length) 3639923ae0ffSRoss Zwisler { 3640923ae0ffSRoss Zwisler struct inode *inode = mapping->host; 3641923ae0ffSRoss Zwisler unsigned offset = from & (PAGE_CACHE_SIZE-1); 3642923ae0ffSRoss Zwisler unsigned blocksize = inode->i_sb->s_blocksize; 3643923ae0ffSRoss Zwisler unsigned max = blocksize - (offset & (blocksize - 1)); 3644923ae0ffSRoss Zwisler 3645923ae0ffSRoss Zwisler /* 3646923ae0ffSRoss Zwisler * correct length if it does not fall between 3647923ae0ffSRoss Zwisler * 'from' and the end of the block 3648923ae0ffSRoss Zwisler */ 3649923ae0ffSRoss Zwisler if (length > max || length < 0) 3650923ae0ffSRoss Zwisler length = max; 3651923ae0ffSRoss Zwisler 3652923ae0ffSRoss Zwisler if (IS_DAX(inode)) 3653923ae0ffSRoss Zwisler return dax_zero_page_range(inode, from, length, ext4_get_block); 3654923ae0ffSRoss Zwisler return __ext4_block_zero_page_range(handle, mapping, from, length); 3655923ae0ffSRoss Zwisler } 3656923ae0ffSRoss Zwisler 3657923ae0ffSRoss Zwisler /* 365894350ab5SMatthew Wilcox * ext4_block_truncate_page() zeroes out a mapping from file offset `from' 365994350ab5SMatthew Wilcox * up to the end of the block which corresponds to `from'. 366094350ab5SMatthew Wilcox * This required during truncate. We need to physically zero the tail end 366194350ab5SMatthew Wilcox * of that block so it doesn't yield old data if the file is later grown. 366294350ab5SMatthew Wilcox */ 3663c197855eSStephen Hemminger static int ext4_block_truncate_page(handle_t *handle, 366494350ab5SMatthew Wilcox struct address_space *mapping, loff_t from) 366594350ab5SMatthew Wilcox { 366694350ab5SMatthew Wilcox unsigned offset = from & (PAGE_CACHE_SIZE-1); 366794350ab5SMatthew Wilcox unsigned length; 366894350ab5SMatthew Wilcox unsigned blocksize; 366994350ab5SMatthew Wilcox struct inode *inode = mapping->host; 367094350ab5SMatthew Wilcox 367194350ab5SMatthew Wilcox blocksize = inode->i_sb->s_blocksize; 367294350ab5SMatthew Wilcox length = blocksize - (offset & (blocksize - 1)); 367394350ab5SMatthew Wilcox 367494350ab5SMatthew Wilcox return ext4_block_zero_page_range(handle, mapping, from, length); 367594350ab5SMatthew Wilcox } 367694350ab5SMatthew Wilcox 3677a87dd18cSLukas Czerner int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode, 3678a87dd18cSLukas Czerner loff_t lstart, loff_t length) 3679a87dd18cSLukas Czerner { 3680a87dd18cSLukas Czerner struct super_block *sb = inode->i_sb; 3681a87dd18cSLukas Czerner struct address_space *mapping = inode->i_mapping; 3682e1be3a92SLukas Czerner unsigned partial_start, partial_end; 3683a87dd18cSLukas Czerner ext4_fsblk_t start, end; 3684a87dd18cSLukas Czerner loff_t byte_end = (lstart + length - 1); 3685a87dd18cSLukas Czerner int err = 0; 3686a87dd18cSLukas Czerner 3687e1be3a92SLukas Czerner partial_start = lstart & (sb->s_blocksize - 1); 3688e1be3a92SLukas Czerner partial_end = byte_end & (sb->s_blocksize - 1); 3689e1be3a92SLukas Czerner 3690a87dd18cSLukas Czerner start = lstart >> sb->s_blocksize_bits; 3691a87dd18cSLukas Czerner end = byte_end >> sb->s_blocksize_bits; 3692a87dd18cSLukas Czerner 3693a87dd18cSLukas Czerner /* Handle partial zero within the single block */ 3694e1be3a92SLukas Czerner if (start == end && 3695e1be3a92SLukas Czerner (partial_start || (partial_end != sb->s_blocksize - 1))) { 3696a87dd18cSLukas Czerner err = ext4_block_zero_page_range(handle, mapping, 3697a87dd18cSLukas Czerner lstart, length); 3698a87dd18cSLukas Czerner return err; 3699a87dd18cSLukas Czerner } 3700a87dd18cSLukas Czerner /* Handle partial zero out on the start of the range */ 3701e1be3a92SLukas Czerner if (partial_start) { 3702a87dd18cSLukas Czerner err = ext4_block_zero_page_range(handle, mapping, 3703a87dd18cSLukas Czerner lstart, sb->s_blocksize); 3704a87dd18cSLukas Czerner if (err) 3705a87dd18cSLukas Czerner return err; 3706a87dd18cSLukas Czerner } 3707a87dd18cSLukas Czerner /* Handle partial zero out on the end of the range */ 3708e1be3a92SLukas Czerner if (partial_end != sb->s_blocksize - 1) 3709a87dd18cSLukas Czerner err = ext4_block_zero_page_range(handle, mapping, 3710e1be3a92SLukas Czerner byte_end - partial_end, 3711e1be3a92SLukas Czerner partial_end + 1); 3712a87dd18cSLukas Czerner return err; 3713a87dd18cSLukas Czerner } 3714a87dd18cSLukas Czerner 371591ef4cafSDuane Griffin int ext4_can_truncate(struct inode *inode) 371691ef4cafSDuane Griffin { 371791ef4cafSDuane Griffin if (S_ISREG(inode->i_mode)) 371891ef4cafSDuane Griffin return 1; 371991ef4cafSDuane Griffin if (S_ISDIR(inode->i_mode)) 372091ef4cafSDuane Griffin return 1; 372191ef4cafSDuane Griffin if (S_ISLNK(inode->i_mode)) 372291ef4cafSDuane Griffin return !ext4_inode_is_fast_symlink(inode); 372391ef4cafSDuane Griffin return 0; 372491ef4cafSDuane Griffin } 372591ef4cafSDuane Griffin 3726ac27a0ecSDave Kleikamp /* 372701127848SJan Kara * We have to make sure i_disksize gets properly updated before we truncate 372801127848SJan Kara * page cache due to hole punching or zero range. Otherwise i_disksize update 372901127848SJan Kara * can get lost as it may have been postponed to submission of writeback but 373001127848SJan Kara * that will never happen after we truncate page cache. 373101127848SJan Kara */ 373201127848SJan Kara int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset, 373301127848SJan Kara loff_t len) 373401127848SJan Kara { 373501127848SJan Kara handle_t *handle; 373601127848SJan Kara loff_t size = i_size_read(inode); 373701127848SJan Kara 37385955102cSAl Viro WARN_ON(!inode_is_locked(inode)); 373901127848SJan Kara if (offset > size || offset + len < size) 374001127848SJan Kara return 0; 374101127848SJan Kara 374201127848SJan Kara if (EXT4_I(inode)->i_disksize >= size) 374301127848SJan Kara return 0; 374401127848SJan Kara 374501127848SJan Kara handle = ext4_journal_start(inode, EXT4_HT_MISC, 1); 374601127848SJan Kara if (IS_ERR(handle)) 374701127848SJan Kara return PTR_ERR(handle); 374801127848SJan Kara ext4_update_i_disksize(inode, size); 374901127848SJan Kara ext4_mark_inode_dirty(handle, inode); 375001127848SJan Kara ext4_journal_stop(handle); 375101127848SJan Kara 375201127848SJan Kara return 0; 375301127848SJan Kara } 375401127848SJan Kara 375501127848SJan Kara /* 3756a4bb6b64SAllison Henderson * ext4_punch_hole: punches a hole in a file by releaseing the blocks 3757a4bb6b64SAllison Henderson * associated with the given offset and length 3758a4bb6b64SAllison Henderson * 3759a4bb6b64SAllison Henderson * @inode: File inode 3760a4bb6b64SAllison Henderson * @offset: The offset where the hole will begin 3761a4bb6b64SAllison Henderson * @len: The length of the hole 3762a4bb6b64SAllison Henderson * 37634907cb7bSAnatol Pomozov * Returns: 0 on success or negative on failure 3764a4bb6b64SAllison Henderson */ 3765a4bb6b64SAllison Henderson 3766aeb2817aSAshish Sangwan int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length) 3767a4bb6b64SAllison Henderson { 376826a4c0c6STheodore Ts'o struct super_block *sb = inode->i_sb; 376926a4c0c6STheodore Ts'o ext4_lblk_t first_block, stop_block; 377026a4c0c6STheodore Ts'o struct address_space *mapping = inode->i_mapping; 3771a87dd18cSLukas Czerner loff_t first_block_offset, last_block_offset; 377226a4c0c6STheodore Ts'o handle_t *handle; 377326a4c0c6STheodore Ts'o unsigned int credits; 377426a4c0c6STheodore Ts'o int ret = 0; 377526a4c0c6STheodore Ts'o 3776a4bb6b64SAllison Henderson if (!S_ISREG(inode->i_mode)) 377773355192SAllison Henderson return -EOPNOTSUPP; 3778a4bb6b64SAllison Henderson 3779b8a86845SLukas Czerner trace_ext4_punch_hole(inode, offset, length, 0); 3780aaddea81SZheng Liu 378126a4c0c6STheodore Ts'o /* 378226a4c0c6STheodore Ts'o * Write out all dirty pages to avoid race conditions 378326a4c0c6STheodore Ts'o * Then release them. 378426a4c0c6STheodore Ts'o */ 378526a4c0c6STheodore Ts'o if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) { 378626a4c0c6STheodore Ts'o ret = filemap_write_and_wait_range(mapping, offset, 378726a4c0c6STheodore Ts'o offset + length - 1); 378826a4c0c6STheodore Ts'o if (ret) 378926a4c0c6STheodore Ts'o return ret; 379026a4c0c6STheodore Ts'o } 379126a4c0c6STheodore Ts'o 37925955102cSAl Viro inode_lock(inode); 37939ef06cecSLukas Czerner 379426a4c0c6STheodore Ts'o /* No need to punch hole beyond i_size */ 379526a4c0c6STheodore Ts'o if (offset >= inode->i_size) 379626a4c0c6STheodore Ts'o goto out_mutex; 379726a4c0c6STheodore Ts'o 379826a4c0c6STheodore Ts'o /* 379926a4c0c6STheodore Ts'o * If the hole extends beyond i_size, set the hole 380026a4c0c6STheodore Ts'o * to end after the page that contains i_size 380126a4c0c6STheodore Ts'o */ 380226a4c0c6STheodore Ts'o if (offset + length > inode->i_size) { 380326a4c0c6STheodore Ts'o length = inode->i_size + 380426a4c0c6STheodore Ts'o PAGE_CACHE_SIZE - (inode->i_size & (PAGE_CACHE_SIZE - 1)) - 380526a4c0c6STheodore Ts'o offset; 380626a4c0c6STheodore Ts'o } 380726a4c0c6STheodore Ts'o 3808a361293fSJan Kara if (offset & (sb->s_blocksize - 1) || 3809a361293fSJan Kara (offset + length) & (sb->s_blocksize - 1)) { 3810a361293fSJan Kara /* 3811a361293fSJan Kara * Attach jinode to inode for jbd2 if we do any zeroing of 3812a361293fSJan Kara * partial block 3813a361293fSJan Kara */ 3814a361293fSJan Kara ret = ext4_inode_attach_jinode(inode); 3815a361293fSJan Kara if (ret < 0) 3816a361293fSJan Kara goto out_mutex; 3817a361293fSJan Kara 3818a361293fSJan Kara } 3819a361293fSJan Kara 3820ea3d7209SJan Kara /* Wait all existing dio workers, newcomers will block on i_mutex */ 3821ea3d7209SJan Kara ext4_inode_block_unlocked_dio(inode); 3822ea3d7209SJan Kara inode_dio_wait(inode); 3823ea3d7209SJan Kara 3824ea3d7209SJan Kara /* 3825ea3d7209SJan Kara * Prevent page faults from reinstantiating pages we have released from 3826ea3d7209SJan Kara * page cache. 3827ea3d7209SJan Kara */ 3828ea3d7209SJan Kara down_write(&EXT4_I(inode)->i_mmap_sem); 3829a87dd18cSLukas Czerner first_block_offset = round_up(offset, sb->s_blocksize); 3830a87dd18cSLukas Czerner last_block_offset = round_down((offset + length), sb->s_blocksize) - 1; 383126a4c0c6STheodore Ts'o 3832a87dd18cSLukas Czerner /* Now release the pages and zero block aligned part of pages*/ 383301127848SJan Kara if (last_block_offset > first_block_offset) { 383401127848SJan Kara ret = ext4_update_disksize_before_punch(inode, offset, length); 383501127848SJan Kara if (ret) 383601127848SJan Kara goto out_dio; 3837a87dd18cSLukas Czerner truncate_pagecache_range(inode, first_block_offset, 3838a87dd18cSLukas Czerner last_block_offset); 383901127848SJan Kara } 384026a4c0c6STheodore Ts'o 384126a4c0c6STheodore Ts'o if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) 384226a4c0c6STheodore Ts'o credits = ext4_writepage_trans_blocks(inode); 384326a4c0c6STheodore Ts'o else 384426a4c0c6STheodore Ts'o credits = ext4_blocks_for_truncate(inode); 384526a4c0c6STheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits); 384626a4c0c6STheodore Ts'o if (IS_ERR(handle)) { 384726a4c0c6STheodore Ts'o ret = PTR_ERR(handle); 384826a4c0c6STheodore Ts'o ext4_std_error(sb, ret); 384926a4c0c6STheodore Ts'o goto out_dio; 385026a4c0c6STheodore Ts'o } 385126a4c0c6STheodore Ts'o 3852a87dd18cSLukas Czerner ret = ext4_zero_partial_blocks(handle, inode, offset, 3853a87dd18cSLukas Czerner length); 385426a4c0c6STheodore Ts'o if (ret) 385526a4c0c6STheodore Ts'o goto out_stop; 385626a4c0c6STheodore Ts'o 385726a4c0c6STheodore Ts'o first_block = (offset + sb->s_blocksize - 1) >> 385826a4c0c6STheodore Ts'o EXT4_BLOCK_SIZE_BITS(sb); 385926a4c0c6STheodore Ts'o stop_block = (offset + length) >> EXT4_BLOCK_SIZE_BITS(sb); 386026a4c0c6STheodore Ts'o 386126a4c0c6STheodore Ts'o /* If there are no blocks to remove, return now */ 386226a4c0c6STheodore Ts'o if (first_block >= stop_block) 386326a4c0c6STheodore Ts'o goto out_stop; 386426a4c0c6STheodore Ts'o 386526a4c0c6STheodore Ts'o down_write(&EXT4_I(inode)->i_data_sem); 386626a4c0c6STheodore Ts'o ext4_discard_preallocations(inode); 386726a4c0c6STheodore Ts'o 386826a4c0c6STheodore Ts'o ret = ext4_es_remove_extent(inode, first_block, 386926a4c0c6STheodore Ts'o stop_block - first_block); 387026a4c0c6STheodore Ts'o if (ret) { 387126a4c0c6STheodore Ts'o up_write(&EXT4_I(inode)->i_data_sem); 387226a4c0c6STheodore Ts'o goto out_stop; 387326a4c0c6STheodore Ts'o } 387426a4c0c6STheodore Ts'o 387526a4c0c6STheodore Ts'o if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) 387626a4c0c6STheodore Ts'o ret = ext4_ext_remove_space(inode, first_block, 387726a4c0c6STheodore Ts'o stop_block - 1); 387826a4c0c6STheodore Ts'o else 38794f579ae7SLukas Czerner ret = ext4_ind_remove_space(handle, inode, first_block, 388026a4c0c6STheodore Ts'o stop_block); 388126a4c0c6STheodore Ts'o 3882819c4920STheodore Ts'o up_write(&EXT4_I(inode)->i_data_sem); 388326a4c0c6STheodore Ts'o if (IS_SYNC(inode)) 388426a4c0c6STheodore Ts'o ext4_handle_sync(handle); 3885e251f9bcSMaxim Patlasov 388626a4c0c6STheodore Ts'o inode->i_mtime = inode->i_ctime = ext4_current_time(inode); 388726a4c0c6STheodore Ts'o ext4_mark_inode_dirty(handle, inode); 388826a4c0c6STheodore Ts'o out_stop: 388926a4c0c6STheodore Ts'o ext4_journal_stop(handle); 389026a4c0c6STheodore Ts'o out_dio: 3891ea3d7209SJan Kara up_write(&EXT4_I(inode)->i_mmap_sem); 389226a4c0c6STheodore Ts'o ext4_inode_resume_unlocked_dio(inode); 389326a4c0c6STheodore Ts'o out_mutex: 38945955102cSAl Viro inode_unlock(inode); 389526a4c0c6STheodore Ts'o return ret; 3896a4bb6b64SAllison Henderson } 3897a4bb6b64SAllison Henderson 3898a361293fSJan Kara int ext4_inode_attach_jinode(struct inode *inode) 3899a361293fSJan Kara { 3900a361293fSJan Kara struct ext4_inode_info *ei = EXT4_I(inode); 3901a361293fSJan Kara struct jbd2_inode *jinode; 3902a361293fSJan Kara 3903a361293fSJan Kara if (ei->jinode || !EXT4_SB(inode->i_sb)->s_journal) 3904a361293fSJan Kara return 0; 3905a361293fSJan Kara 3906a361293fSJan Kara jinode = jbd2_alloc_inode(GFP_KERNEL); 3907a361293fSJan Kara spin_lock(&inode->i_lock); 3908a361293fSJan Kara if (!ei->jinode) { 3909a361293fSJan Kara if (!jinode) { 3910a361293fSJan Kara spin_unlock(&inode->i_lock); 3911a361293fSJan Kara return -ENOMEM; 3912a361293fSJan Kara } 3913a361293fSJan Kara ei->jinode = jinode; 3914a361293fSJan Kara jbd2_journal_init_jbd_inode(ei->jinode, inode); 3915a361293fSJan Kara jinode = NULL; 3916a361293fSJan Kara } 3917a361293fSJan Kara spin_unlock(&inode->i_lock); 3918a361293fSJan Kara if (unlikely(jinode != NULL)) 3919a361293fSJan Kara jbd2_free_inode(jinode); 3920a361293fSJan Kara return 0; 3921a361293fSJan Kara } 3922a361293fSJan Kara 3923a4bb6b64SAllison Henderson /* 3924617ba13bSMingming Cao * ext4_truncate() 3925ac27a0ecSDave Kleikamp * 3926617ba13bSMingming Cao * We block out ext4_get_block() block instantiations across the entire 3927617ba13bSMingming Cao * transaction, and VFS/VM ensures that ext4_truncate() cannot run 3928ac27a0ecSDave Kleikamp * simultaneously on behalf of the same inode. 3929ac27a0ecSDave Kleikamp * 393042b2aa86SJustin P. Mattock * As we work through the truncate and commit bits of it to the journal there 3931ac27a0ecSDave Kleikamp * is one core, guiding principle: the file's tree must always be consistent on 3932ac27a0ecSDave Kleikamp * disk. We must be able to restart the truncate after a crash. 3933ac27a0ecSDave Kleikamp * 3934ac27a0ecSDave Kleikamp * The file's tree may be transiently inconsistent in memory (although it 3935ac27a0ecSDave Kleikamp * probably isn't), but whenever we close off and commit a journal transaction, 3936ac27a0ecSDave Kleikamp * the contents of (the filesystem + the journal) must be consistent and 3937ac27a0ecSDave Kleikamp * restartable. It's pretty simple, really: bottom up, right to left (although 3938ac27a0ecSDave Kleikamp * left-to-right works OK too). 3939ac27a0ecSDave Kleikamp * 3940ac27a0ecSDave Kleikamp * Note that at recovery time, journal replay occurs *before* the restart of 3941ac27a0ecSDave Kleikamp * truncate against the orphan inode list. 3942ac27a0ecSDave Kleikamp * 3943ac27a0ecSDave Kleikamp * The committed inode has the new, desired i_size (which is the same as 3944617ba13bSMingming Cao * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see 3945ac27a0ecSDave Kleikamp * that this inode's truncate did not complete and it will again call 3946617ba13bSMingming Cao * ext4_truncate() to have another go. So there will be instantiated blocks 3947617ba13bSMingming Cao * to the right of the truncation point in a crashed ext4 filesystem. But 3948ac27a0ecSDave Kleikamp * that's fine - as long as they are linked from the inode, the post-crash 3949617ba13bSMingming Cao * ext4_truncate() run will find them and release them. 3950ac27a0ecSDave Kleikamp */ 3951617ba13bSMingming Cao void ext4_truncate(struct inode *inode) 3952ac27a0ecSDave Kleikamp { 3953819c4920STheodore Ts'o struct ext4_inode_info *ei = EXT4_I(inode); 3954819c4920STheodore Ts'o unsigned int credits; 3955819c4920STheodore Ts'o handle_t *handle; 3956819c4920STheodore Ts'o struct address_space *mapping = inode->i_mapping; 3957819c4920STheodore Ts'o 395819b5ef61STheodore Ts'o /* 395919b5ef61STheodore Ts'o * There is a possibility that we're either freeing the inode 3960e04027e8SMatthew Wilcox * or it's a completely new inode. In those cases we might not 396119b5ef61STheodore Ts'o * have i_mutex locked because it's not necessary. 396219b5ef61STheodore Ts'o */ 396319b5ef61STheodore Ts'o if (!(inode->i_state & (I_NEW|I_FREEING))) 39645955102cSAl Viro WARN_ON(!inode_is_locked(inode)); 39650562e0baSJiaying Zhang trace_ext4_truncate_enter(inode); 39660562e0baSJiaying Zhang 396791ef4cafSDuane Griffin if (!ext4_can_truncate(inode)) 3968ac27a0ecSDave Kleikamp return; 3969ac27a0ecSDave Kleikamp 397012e9b892SDmitry Monakhov ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS); 3971c8d46e41SJiaying Zhang 39725534fb5bSTheodore Ts'o if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC)) 397319f5fb7aSTheodore Ts'o ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE); 39747d8f9f7dSTheodore Ts'o 3975aef1c851STao Ma if (ext4_has_inline_data(inode)) { 3976aef1c851STao Ma int has_inline = 1; 3977aef1c851STao Ma 3978aef1c851STao Ma ext4_inline_data_truncate(inode, &has_inline); 3979aef1c851STao Ma if (has_inline) 3980aef1c851STao Ma return; 3981aef1c851STao Ma } 3982aef1c851STao Ma 3983a361293fSJan Kara /* If we zero-out tail of the page, we have to create jinode for jbd2 */ 3984a361293fSJan Kara if (inode->i_size & (inode->i_sb->s_blocksize - 1)) { 3985a361293fSJan Kara if (ext4_inode_attach_jinode(inode) < 0) 3986a361293fSJan Kara return; 3987a361293fSJan Kara } 3988a361293fSJan Kara 3989ff9893dcSAmir Goldstein if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) 3990819c4920STheodore Ts'o credits = ext4_writepage_trans_blocks(inode); 3991ff9893dcSAmir Goldstein else 3992819c4920STheodore Ts'o credits = ext4_blocks_for_truncate(inode); 3993819c4920STheodore Ts'o 3994819c4920STheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits); 3995819c4920STheodore Ts'o if (IS_ERR(handle)) { 3996819c4920STheodore Ts'o ext4_std_error(inode->i_sb, PTR_ERR(handle)); 3997819c4920STheodore Ts'o return; 3998819c4920STheodore Ts'o } 3999819c4920STheodore Ts'o 4000eb3544c6SLukas Czerner if (inode->i_size & (inode->i_sb->s_blocksize - 1)) 4001eb3544c6SLukas Czerner ext4_block_truncate_page(handle, mapping, inode->i_size); 4002819c4920STheodore Ts'o 4003819c4920STheodore Ts'o /* 4004819c4920STheodore Ts'o * We add the inode to the orphan list, so that if this 4005819c4920STheodore Ts'o * truncate spans multiple transactions, and we crash, we will 4006819c4920STheodore Ts'o * resume the truncate when the filesystem recovers. It also 4007819c4920STheodore Ts'o * marks the inode dirty, to catch the new size. 4008819c4920STheodore Ts'o * 4009819c4920STheodore Ts'o * Implication: the file must always be in a sane, consistent 4010819c4920STheodore Ts'o * truncatable state while each transaction commits. 4011819c4920STheodore Ts'o */ 4012819c4920STheodore Ts'o if (ext4_orphan_add(handle, inode)) 4013819c4920STheodore Ts'o goto out_stop; 4014819c4920STheodore Ts'o 4015819c4920STheodore Ts'o down_write(&EXT4_I(inode)->i_data_sem); 4016819c4920STheodore Ts'o 4017819c4920STheodore Ts'o ext4_discard_preallocations(inode); 4018819c4920STheodore Ts'o 4019819c4920STheodore Ts'o if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) 4020819c4920STheodore Ts'o ext4_ext_truncate(handle, inode); 4021819c4920STheodore Ts'o else 4022819c4920STheodore Ts'o ext4_ind_truncate(handle, inode); 4023819c4920STheodore Ts'o 4024819c4920STheodore Ts'o up_write(&ei->i_data_sem); 4025819c4920STheodore Ts'o 4026819c4920STheodore Ts'o if (IS_SYNC(inode)) 4027819c4920STheodore Ts'o ext4_handle_sync(handle); 4028819c4920STheodore Ts'o 4029819c4920STheodore Ts'o out_stop: 4030819c4920STheodore Ts'o /* 4031819c4920STheodore Ts'o * If this was a simple ftruncate() and the file will remain alive, 4032819c4920STheodore Ts'o * then we need to clear up the orphan record which we created above. 4033819c4920STheodore Ts'o * However, if this was a real unlink then we were called by 403458d86a50SWang Shilong * ext4_evict_inode(), and we allow that function to clean up the 4035819c4920STheodore Ts'o * orphan info for us. 4036819c4920STheodore Ts'o */ 4037819c4920STheodore Ts'o if (inode->i_nlink) 4038819c4920STheodore Ts'o ext4_orphan_del(handle, inode); 4039819c4920STheodore Ts'o 4040819c4920STheodore Ts'o inode->i_mtime = inode->i_ctime = ext4_current_time(inode); 4041819c4920STheodore Ts'o ext4_mark_inode_dirty(handle, inode); 4042819c4920STheodore Ts'o ext4_journal_stop(handle); 4043a86c6181SAlex Tomas 40440562e0baSJiaying Zhang trace_ext4_truncate_exit(inode); 4045ac27a0ecSDave Kleikamp } 4046ac27a0ecSDave Kleikamp 4047ac27a0ecSDave Kleikamp /* 4048617ba13bSMingming Cao * ext4_get_inode_loc returns with an extra refcount against the inode's 4049ac27a0ecSDave Kleikamp * underlying buffer_head on success. If 'in_mem' is true, we have all 4050ac27a0ecSDave Kleikamp * data in memory that is needed to recreate the on-disk version of this 4051ac27a0ecSDave Kleikamp * inode. 4052ac27a0ecSDave Kleikamp */ 4053617ba13bSMingming Cao static int __ext4_get_inode_loc(struct inode *inode, 4054617ba13bSMingming Cao struct ext4_iloc *iloc, int in_mem) 4055ac27a0ecSDave Kleikamp { 4056240799cdSTheodore Ts'o struct ext4_group_desc *gdp; 4057ac27a0ecSDave Kleikamp struct buffer_head *bh; 4058240799cdSTheodore Ts'o struct super_block *sb = inode->i_sb; 4059240799cdSTheodore Ts'o ext4_fsblk_t block; 4060240799cdSTheodore Ts'o int inodes_per_block, inode_offset; 4061ac27a0ecSDave Kleikamp 40623a06d778SAneesh Kumar K.V iloc->bh = NULL; 4063240799cdSTheodore Ts'o if (!ext4_valid_inum(sb, inode->i_ino)) 40646a797d27SDarrick J. Wong return -EFSCORRUPTED; 4065ac27a0ecSDave Kleikamp 4066240799cdSTheodore Ts'o iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb); 4067240799cdSTheodore Ts'o gdp = ext4_get_group_desc(sb, iloc->block_group, NULL); 4068240799cdSTheodore Ts'o if (!gdp) 4069240799cdSTheodore Ts'o return -EIO; 4070240799cdSTheodore Ts'o 4071240799cdSTheodore Ts'o /* 4072240799cdSTheodore Ts'o * Figure out the offset within the block group inode table 4073240799cdSTheodore Ts'o */ 407400d09882STao Ma inodes_per_block = EXT4_SB(sb)->s_inodes_per_block; 4075240799cdSTheodore Ts'o inode_offset = ((inode->i_ino - 1) % 4076240799cdSTheodore Ts'o EXT4_INODES_PER_GROUP(sb)); 4077240799cdSTheodore Ts'o block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block); 4078240799cdSTheodore Ts'o iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb); 4079240799cdSTheodore Ts'o 4080240799cdSTheodore Ts'o bh = sb_getblk(sb, block); 4081aebf0243SWang Shilong if (unlikely(!bh)) 4082860d21e2STheodore Ts'o return -ENOMEM; 4083ac27a0ecSDave Kleikamp if (!buffer_uptodate(bh)) { 4084ac27a0ecSDave Kleikamp lock_buffer(bh); 40859c83a923SHidehiro Kawai 40869c83a923SHidehiro Kawai /* 40879c83a923SHidehiro Kawai * If the buffer has the write error flag, we have failed 40889c83a923SHidehiro Kawai * to write out another inode in the same block. In this 40899c83a923SHidehiro Kawai * case, we don't have to read the block because we may 40909c83a923SHidehiro Kawai * read the old inode data successfully. 40919c83a923SHidehiro Kawai */ 40929c83a923SHidehiro Kawai if (buffer_write_io_error(bh) && !buffer_uptodate(bh)) 40939c83a923SHidehiro Kawai set_buffer_uptodate(bh); 40949c83a923SHidehiro Kawai 4095ac27a0ecSDave Kleikamp if (buffer_uptodate(bh)) { 4096ac27a0ecSDave Kleikamp /* someone brought it uptodate while we waited */ 4097ac27a0ecSDave Kleikamp unlock_buffer(bh); 4098ac27a0ecSDave Kleikamp goto has_buffer; 4099ac27a0ecSDave Kleikamp } 4100ac27a0ecSDave Kleikamp 4101ac27a0ecSDave Kleikamp /* 4102ac27a0ecSDave Kleikamp * If we have all information of the inode in memory and this 4103ac27a0ecSDave Kleikamp * is the only valid inode in the block, we need not read the 4104ac27a0ecSDave Kleikamp * block. 4105ac27a0ecSDave Kleikamp */ 4106ac27a0ecSDave Kleikamp if (in_mem) { 4107ac27a0ecSDave Kleikamp struct buffer_head *bitmap_bh; 4108240799cdSTheodore Ts'o int i, start; 4109ac27a0ecSDave Kleikamp 4110240799cdSTheodore Ts'o start = inode_offset & ~(inodes_per_block - 1); 4111ac27a0ecSDave Kleikamp 4112ac27a0ecSDave Kleikamp /* Is the inode bitmap in cache? */ 4113240799cdSTheodore Ts'o bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp)); 4114aebf0243SWang Shilong if (unlikely(!bitmap_bh)) 4115ac27a0ecSDave Kleikamp goto make_io; 4116ac27a0ecSDave Kleikamp 4117ac27a0ecSDave Kleikamp /* 4118ac27a0ecSDave Kleikamp * If the inode bitmap isn't in cache then the 4119ac27a0ecSDave Kleikamp * optimisation may end up performing two reads instead 4120ac27a0ecSDave Kleikamp * of one, so skip it. 4121ac27a0ecSDave Kleikamp */ 4122ac27a0ecSDave Kleikamp if (!buffer_uptodate(bitmap_bh)) { 4123ac27a0ecSDave Kleikamp brelse(bitmap_bh); 4124ac27a0ecSDave Kleikamp goto make_io; 4125ac27a0ecSDave Kleikamp } 4126240799cdSTheodore Ts'o for (i = start; i < start + inodes_per_block; i++) { 4127ac27a0ecSDave Kleikamp if (i == inode_offset) 4128ac27a0ecSDave Kleikamp continue; 4129617ba13bSMingming Cao if (ext4_test_bit(i, bitmap_bh->b_data)) 4130ac27a0ecSDave Kleikamp break; 4131ac27a0ecSDave Kleikamp } 4132ac27a0ecSDave Kleikamp brelse(bitmap_bh); 4133240799cdSTheodore Ts'o if (i == start + inodes_per_block) { 4134ac27a0ecSDave Kleikamp /* all other inodes are free, so skip I/O */ 4135ac27a0ecSDave Kleikamp memset(bh->b_data, 0, bh->b_size); 4136ac27a0ecSDave Kleikamp set_buffer_uptodate(bh); 4137ac27a0ecSDave Kleikamp unlock_buffer(bh); 4138ac27a0ecSDave Kleikamp goto has_buffer; 4139ac27a0ecSDave Kleikamp } 4140ac27a0ecSDave Kleikamp } 4141ac27a0ecSDave Kleikamp 4142ac27a0ecSDave Kleikamp make_io: 4143ac27a0ecSDave Kleikamp /* 4144240799cdSTheodore Ts'o * If we need to do any I/O, try to pre-readahead extra 4145240799cdSTheodore Ts'o * blocks from the inode table. 4146240799cdSTheodore Ts'o */ 4147240799cdSTheodore Ts'o if (EXT4_SB(sb)->s_inode_readahead_blks) { 4148240799cdSTheodore Ts'o ext4_fsblk_t b, end, table; 4149240799cdSTheodore Ts'o unsigned num; 41500d606e2cSTheodore Ts'o __u32 ra_blks = EXT4_SB(sb)->s_inode_readahead_blks; 4151240799cdSTheodore Ts'o 4152240799cdSTheodore Ts'o table = ext4_inode_table(sb, gdp); 4153b713a5ecSTheodore Ts'o /* s_inode_readahead_blks is always a power of 2 */ 41540d606e2cSTheodore Ts'o b = block & ~((ext4_fsblk_t) ra_blks - 1); 4155240799cdSTheodore Ts'o if (table > b) 4156240799cdSTheodore Ts'o b = table; 41570d606e2cSTheodore Ts'o end = b + ra_blks; 4158240799cdSTheodore Ts'o num = EXT4_INODES_PER_GROUP(sb); 4159feb0ab32SDarrick J. Wong if (ext4_has_group_desc_csum(sb)) 4160560671a0SAneesh Kumar K.V num -= ext4_itable_unused_count(sb, gdp); 4161240799cdSTheodore Ts'o table += num / inodes_per_block; 4162240799cdSTheodore Ts'o if (end > table) 4163240799cdSTheodore Ts'o end = table; 4164240799cdSTheodore Ts'o while (b <= end) 4165240799cdSTheodore Ts'o sb_breadahead(sb, b++); 4166240799cdSTheodore Ts'o } 4167240799cdSTheodore Ts'o 4168240799cdSTheodore Ts'o /* 4169ac27a0ecSDave Kleikamp * There are other valid inodes in the buffer, this inode 4170ac27a0ecSDave Kleikamp * has in-inode xattrs, or we don't have this inode in memory. 4171ac27a0ecSDave Kleikamp * Read the block from disk. 4172ac27a0ecSDave Kleikamp */ 41730562e0baSJiaying Zhang trace_ext4_load_inode(inode); 4174ac27a0ecSDave Kleikamp get_bh(bh); 4175ac27a0ecSDave Kleikamp bh->b_end_io = end_buffer_read_sync; 417665299a3bSChristoph Hellwig submit_bh(READ | REQ_META | REQ_PRIO, bh); 4177ac27a0ecSDave Kleikamp wait_on_buffer(bh); 4178ac27a0ecSDave Kleikamp if (!buffer_uptodate(bh)) { 4179c398eda0STheodore Ts'o EXT4_ERROR_INODE_BLOCK(inode, block, 4180c398eda0STheodore Ts'o "unable to read itable block"); 4181ac27a0ecSDave Kleikamp brelse(bh); 4182ac27a0ecSDave Kleikamp return -EIO; 4183ac27a0ecSDave Kleikamp } 4184ac27a0ecSDave Kleikamp } 4185ac27a0ecSDave Kleikamp has_buffer: 4186ac27a0ecSDave Kleikamp iloc->bh = bh; 4187ac27a0ecSDave Kleikamp return 0; 4188ac27a0ecSDave Kleikamp } 4189ac27a0ecSDave Kleikamp 4190617ba13bSMingming Cao int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc) 4191ac27a0ecSDave Kleikamp { 4192ac27a0ecSDave Kleikamp /* We have all inode data except xattrs in memory here. */ 4193617ba13bSMingming Cao return __ext4_get_inode_loc(inode, iloc, 419419f5fb7aSTheodore Ts'o !ext4_test_inode_state(inode, EXT4_STATE_XATTR)); 4195ac27a0ecSDave Kleikamp } 4196ac27a0ecSDave Kleikamp 4197617ba13bSMingming Cao void ext4_set_inode_flags(struct inode *inode) 4198ac27a0ecSDave Kleikamp { 4199617ba13bSMingming Cao unsigned int flags = EXT4_I(inode)->i_flags; 420000a1a053STheodore Ts'o unsigned int new_fl = 0; 4201ac27a0ecSDave Kleikamp 4202617ba13bSMingming Cao if (flags & EXT4_SYNC_FL) 420300a1a053STheodore Ts'o new_fl |= S_SYNC; 4204617ba13bSMingming Cao if (flags & EXT4_APPEND_FL) 420500a1a053STheodore Ts'o new_fl |= S_APPEND; 4206617ba13bSMingming Cao if (flags & EXT4_IMMUTABLE_FL) 420700a1a053STheodore Ts'o new_fl |= S_IMMUTABLE; 4208617ba13bSMingming Cao if (flags & EXT4_NOATIME_FL) 420900a1a053STheodore Ts'o new_fl |= S_NOATIME; 4210617ba13bSMingming Cao if (flags & EXT4_DIRSYNC_FL) 421100a1a053STheodore Ts'o new_fl |= S_DIRSYNC; 4212923ae0ffSRoss Zwisler if (test_opt(inode->i_sb, DAX)) 4213923ae0ffSRoss Zwisler new_fl |= S_DAX; 42145f16f322STheodore Ts'o inode_set_flags(inode, new_fl, 4215923ae0ffSRoss Zwisler S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_DAX); 4216ac27a0ecSDave Kleikamp } 4217ac27a0ecSDave Kleikamp 4218ff9ddf7eSJan Kara /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */ 4219ff9ddf7eSJan Kara void ext4_get_inode_flags(struct ext4_inode_info *ei) 4220ff9ddf7eSJan Kara { 422184a8dce2SDmitry Monakhov unsigned int vfs_fl; 422284a8dce2SDmitry Monakhov unsigned long old_fl, new_fl; 4223ff9ddf7eSJan Kara 422484a8dce2SDmitry Monakhov do { 422584a8dce2SDmitry Monakhov vfs_fl = ei->vfs_inode.i_flags; 422684a8dce2SDmitry Monakhov old_fl = ei->i_flags; 422784a8dce2SDmitry Monakhov new_fl = old_fl & ~(EXT4_SYNC_FL|EXT4_APPEND_FL| 422884a8dce2SDmitry Monakhov EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL| 422984a8dce2SDmitry Monakhov EXT4_DIRSYNC_FL); 423084a8dce2SDmitry Monakhov if (vfs_fl & S_SYNC) 423184a8dce2SDmitry Monakhov new_fl |= EXT4_SYNC_FL; 423284a8dce2SDmitry Monakhov if (vfs_fl & S_APPEND) 423384a8dce2SDmitry Monakhov new_fl |= EXT4_APPEND_FL; 423484a8dce2SDmitry Monakhov if (vfs_fl & S_IMMUTABLE) 423584a8dce2SDmitry Monakhov new_fl |= EXT4_IMMUTABLE_FL; 423684a8dce2SDmitry Monakhov if (vfs_fl & S_NOATIME) 423784a8dce2SDmitry Monakhov new_fl |= EXT4_NOATIME_FL; 423884a8dce2SDmitry Monakhov if (vfs_fl & S_DIRSYNC) 423984a8dce2SDmitry Monakhov new_fl |= EXT4_DIRSYNC_FL; 424084a8dce2SDmitry Monakhov } while (cmpxchg(&ei->i_flags, old_fl, new_fl) != old_fl); 4241ff9ddf7eSJan Kara } 4242de9a55b8STheodore Ts'o 42430fc1b451SAneesh Kumar K.V static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode, 42440fc1b451SAneesh Kumar K.V struct ext4_inode_info *ei) 42450fc1b451SAneesh Kumar K.V { 42460fc1b451SAneesh Kumar K.V blkcnt_t i_blocks ; 42478180a562SAneesh Kumar K.V struct inode *inode = &(ei->vfs_inode); 42488180a562SAneesh Kumar K.V struct super_block *sb = inode->i_sb; 42490fc1b451SAneesh Kumar K.V 4250e2b911c5SDarrick J. Wong if (ext4_has_feature_huge_file(sb)) { 42510fc1b451SAneesh Kumar K.V /* we are using combined 48 bit field */ 42520fc1b451SAneesh Kumar K.V i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 | 42530fc1b451SAneesh Kumar K.V le32_to_cpu(raw_inode->i_blocks_lo); 425407a03824STheodore Ts'o if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) { 42558180a562SAneesh Kumar K.V /* i_blocks represent file system block size */ 42568180a562SAneesh Kumar K.V return i_blocks << (inode->i_blkbits - 9); 42578180a562SAneesh Kumar K.V } else { 42580fc1b451SAneesh Kumar K.V return i_blocks; 42598180a562SAneesh Kumar K.V } 42600fc1b451SAneesh Kumar K.V } else { 42610fc1b451SAneesh Kumar K.V return le32_to_cpu(raw_inode->i_blocks_lo); 42620fc1b451SAneesh Kumar K.V } 42630fc1b451SAneesh Kumar K.V } 4264ff9ddf7eSJan Kara 4265152a7b0aSTao Ma static inline void ext4_iget_extra_inode(struct inode *inode, 4266152a7b0aSTao Ma struct ext4_inode *raw_inode, 4267152a7b0aSTao Ma struct ext4_inode_info *ei) 4268152a7b0aSTao Ma { 4269152a7b0aSTao Ma __le32 *magic = (void *)raw_inode + 4270152a7b0aSTao Ma EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize; 427167cf5b09STao Ma if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC)) { 4272152a7b0aSTao Ma ext4_set_inode_state(inode, EXT4_STATE_XATTR); 427367cf5b09STao Ma ext4_find_inline_data_nolock(inode); 4274f19d5870STao Ma } else 4275f19d5870STao Ma EXT4_I(inode)->i_inline_off = 0; 4276152a7b0aSTao Ma } 4277152a7b0aSTao Ma 4278040cb378SLi Xi int ext4_get_projid(struct inode *inode, kprojid_t *projid) 4279040cb378SLi Xi { 4280040cb378SLi Xi if (!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, EXT4_FEATURE_RO_COMPAT_PROJECT)) 4281040cb378SLi Xi return -EOPNOTSUPP; 4282040cb378SLi Xi *projid = EXT4_I(inode)->i_projid; 4283040cb378SLi Xi return 0; 4284040cb378SLi Xi } 4285040cb378SLi Xi 42861d1fe1eeSDavid Howells struct inode *ext4_iget(struct super_block *sb, unsigned long ino) 4287ac27a0ecSDave Kleikamp { 4288617ba13bSMingming Cao struct ext4_iloc iloc; 4289617ba13bSMingming Cao struct ext4_inode *raw_inode; 42901d1fe1eeSDavid Howells struct ext4_inode_info *ei; 42911d1fe1eeSDavid Howells struct inode *inode; 4292b436b9beSJan Kara journal_t *journal = EXT4_SB(sb)->s_journal; 42931d1fe1eeSDavid Howells long ret; 4294ac27a0ecSDave Kleikamp int block; 429508cefc7aSEric W. Biederman uid_t i_uid; 429608cefc7aSEric W. Biederman gid_t i_gid; 4297040cb378SLi Xi projid_t i_projid; 4298ac27a0ecSDave Kleikamp 42991d1fe1eeSDavid Howells inode = iget_locked(sb, ino); 43001d1fe1eeSDavid Howells if (!inode) 43011d1fe1eeSDavid Howells return ERR_PTR(-ENOMEM); 43021d1fe1eeSDavid Howells if (!(inode->i_state & I_NEW)) 43031d1fe1eeSDavid Howells return inode; 43041d1fe1eeSDavid Howells 43051d1fe1eeSDavid Howells ei = EXT4_I(inode); 43067dc57615SPeter Huewe iloc.bh = NULL; 4307ac27a0ecSDave Kleikamp 43081d1fe1eeSDavid Howells ret = __ext4_get_inode_loc(inode, &iloc, 0); 43091d1fe1eeSDavid Howells if (ret < 0) 4310ac27a0ecSDave Kleikamp goto bad_inode; 4311617ba13bSMingming Cao raw_inode = ext4_raw_inode(&iloc); 4312814525f4SDarrick J. Wong 4313814525f4SDarrick J. Wong if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { 4314814525f4SDarrick J. Wong ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize); 4315814525f4SDarrick J. Wong if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize > 4316814525f4SDarrick J. Wong EXT4_INODE_SIZE(inode->i_sb)) { 4317814525f4SDarrick J. Wong EXT4_ERROR_INODE(inode, "bad extra_isize (%u != %u)", 4318814525f4SDarrick J. Wong EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize, 4319814525f4SDarrick J. Wong EXT4_INODE_SIZE(inode->i_sb)); 43206a797d27SDarrick J. Wong ret = -EFSCORRUPTED; 4321814525f4SDarrick J. Wong goto bad_inode; 4322814525f4SDarrick J. Wong } 4323814525f4SDarrick J. Wong } else 4324814525f4SDarrick J. Wong ei->i_extra_isize = 0; 4325814525f4SDarrick J. Wong 4326814525f4SDarrick J. Wong /* Precompute checksum seed for inode metadata */ 43279aa5d32bSDmitry Monakhov if (ext4_has_metadata_csum(sb)) { 4328814525f4SDarrick J. Wong struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 4329814525f4SDarrick J. Wong __u32 csum; 4330814525f4SDarrick J. Wong __le32 inum = cpu_to_le32(inode->i_ino); 4331814525f4SDarrick J. Wong __le32 gen = raw_inode->i_generation; 4332814525f4SDarrick J. Wong csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum, 4333814525f4SDarrick J. Wong sizeof(inum)); 4334814525f4SDarrick J. Wong ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen, 4335814525f4SDarrick J. Wong sizeof(gen)); 4336814525f4SDarrick J. Wong } 4337814525f4SDarrick J. Wong 4338814525f4SDarrick J. Wong if (!ext4_inode_csum_verify(inode, raw_inode, ei)) { 4339814525f4SDarrick J. Wong EXT4_ERROR_INODE(inode, "checksum invalid"); 43406a797d27SDarrick J. Wong ret = -EFSBADCRC; 4341814525f4SDarrick J. Wong goto bad_inode; 4342814525f4SDarrick J. Wong } 4343814525f4SDarrick J. Wong 4344ac27a0ecSDave Kleikamp inode->i_mode = le16_to_cpu(raw_inode->i_mode); 434508cefc7aSEric W. Biederman i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low); 434608cefc7aSEric W. Biederman i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low); 4347040cb378SLi Xi if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_PROJECT) && 4348040cb378SLi Xi EXT4_INODE_SIZE(sb) > EXT4_GOOD_OLD_INODE_SIZE && 4349040cb378SLi Xi EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) 4350040cb378SLi Xi i_projid = (projid_t)le32_to_cpu(raw_inode->i_projid); 4351040cb378SLi Xi else 4352040cb378SLi Xi i_projid = EXT4_DEF_PROJID; 4353040cb378SLi Xi 4354ac27a0ecSDave Kleikamp if (!(test_opt(inode->i_sb, NO_UID32))) { 435508cefc7aSEric W. Biederman i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16; 435608cefc7aSEric W. Biederman i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16; 4357ac27a0ecSDave Kleikamp } 435808cefc7aSEric W. Biederman i_uid_write(inode, i_uid); 435908cefc7aSEric W. Biederman i_gid_write(inode, i_gid); 4360040cb378SLi Xi ei->i_projid = make_kprojid(&init_user_ns, i_projid); 4361bfe86848SMiklos Szeredi set_nlink(inode, le16_to_cpu(raw_inode->i_links_count)); 4362ac27a0ecSDave Kleikamp 4363353eb83cSTheodore Ts'o ext4_clear_state_flags(ei); /* Only relevant on 32-bit archs */ 436467cf5b09STao Ma ei->i_inline_off = 0; 4365ac27a0ecSDave Kleikamp ei->i_dir_start_lookup = 0; 4366ac27a0ecSDave Kleikamp ei->i_dtime = le32_to_cpu(raw_inode->i_dtime); 4367ac27a0ecSDave Kleikamp /* We now have enough fields to check if the inode was active or not. 4368ac27a0ecSDave Kleikamp * This is needed because nfsd might try to access dead inodes 4369ac27a0ecSDave Kleikamp * the test is that same one that e2fsck uses 4370ac27a0ecSDave Kleikamp * NeilBrown 1999oct15 4371ac27a0ecSDave Kleikamp */ 4372ac27a0ecSDave Kleikamp if (inode->i_nlink == 0) { 4373393d1d1dSDr. Tilmann Bubeck if ((inode->i_mode == 0 || 4374393d1d1dSDr. Tilmann Bubeck !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) && 4375393d1d1dSDr. Tilmann Bubeck ino != EXT4_BOOT_LOADER_INO) { 4376ac27a0ecSDave Kleikamp /* this inode is deleted */ 43771d1fe1eeSDavid Howells ret = -ESTALE; 4378ac27a0ecSDave Kleikamp goto bad_inode; 4379ac27a0ecSDave Kleikamp } 4380ac27a0ecSDave Kleikamp /* The only unlinked inodes we let through here have 4381ac27a0ecSDave Kleikamp * valid i_mode and are being read by the orphan 4382ac27a0ecSDave Kleikamp * recovery code: that's fine, we're about to complete 4383393d1d1dSDr. Tilmann Bubeck * the process of deleting those. 4384393d1d1dSDr. Tilmann Bubeck * OR it is the EXT4_BOOT_LOADER_INO which is 4385393d1d1dSDr. Tilmann Bubeck * not initialized on a new filesystem. */ 4386ac27a0ecSDave Kleikamp } 4387ac27a0ecSDave Kleikamp ei->i_flags = le32_to_cpu(raw_inode->i_flags); 43880fc1b451SAneesh Kumar K.V inode->i_blocks = ext4_inode_blocks(raw_inode, ei); 43897973c0c1SAneesh Kumar K.V ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo); 4390e2b911c5SDarrick J. Wong if (ext4_has_feature_64bit(sb)) 4391a1ddeb7eSBadari Pulavarty ei->i_file_acl |= 4392a1ddeb7eSBadari Pulavarty ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32; 4393a48380f7SAneesh Kumar K.V inode->i_size = ext4_isize(raw_inode); 4394ac27a0ecSDave Kleikamp ei->i_disksize = inode->i_size; 4395a9e7f447SDmitry Monakhov #ifdef CONFIG_QUOTA 4396a9e7f447SDmitry Monakhov ei->i_reserved_quota = 0; 4397a9e7f447SDmitry Monakhov #endif 4398ac27a0ecSDave Kleikamp inode->i_generation = le32_to_cpu(raw_inode->i_generation); 4399ac27a0ecSDave Kleikamp ei->i_block_group = iloc.block_group; 4400a4912123STheodore Ts'o ei->i_last_alloc_group = ~0; 4401ac27a0ecSDave Kleikamp /* 4402ac27a0ecSDave Kleikamp * NOTE! The in-memory inode i_data array is in little-endian order 4403ac27a0ecSDave Kleikamp * even on big-endian machines: we do NOT byteswap the block numbers! 4404ac27a0ecSDave Kleikamp */ 4405617ba13bSMingming Cao for (block = 0; block < EXT4_N_BLOCKS; block++) 4406ac27a0ecSDave Kleikamp ei->i_data[block] = raw_inode->i_block[block]; 4407ac27a0ecSDave Kleikamp INIT_LIST_HEAD(&ei->i_orphan); 4408ac27a0ecSDave Kleikamp 4409b436b9beSJan Kara /* 4410b436b9beSJan Kara * Set transaction id's of transactions that have to be committed 4411b436b9beSJan Kara * to finish f[data]sync. We set them to currently running transaction 4412b436b9beSJan Kara * as we cannot be sure that the inode or some of its metadata isn't 4413b436b9beSJan Kara * part of the transaction - the inode could have been reclaimed and 4414b436b9beSJan Kara * now it is reread from disk. 4415b436b9beSJan Kara */ 4416b436b9beSJan Kara if (journal) { 4417b436b9beSJan Kara transaction_t *transaction; 4418b436b9beSJan Kara tid_t tid; 4419b436b9beSJan Kara 4420a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 4421b436b9beSJan Kara if (journal->j_running_transaction) 4422b436b9beSJan Kara transaction = journal->j_running_transaction; 4423b436b9beSJan Kara else 4424b436b9beSJan Kara transaction = journal->j_committing_transaction; 4425b436b9beSJan Kara if (transaction) 4426b436b9beSJan Kara tid = transaction->t_tid; 4427b436b9beSJan Kara else 4428b436b9beSJan Kara tid = journal->j_commit_sequence; 4429a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 4430b436b9beSJan Kara ei->i_sync_tid = tid; 4431b436b9beSJan Kara ei->i_datasync_tid = tid; 4432b436b9beSJan Kara } 4433b436b9beSJan Kara 44340040d987SEric Sandeen if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { 4435ac27a0ecSDave Kleikamp if (ei->i_extra_isize == 0) { 4436ac27a0ecSDave Kleikamp /* The extra space is currently unused. Use it. */ 4437617ba13bSMingming Cao ei->i_extra_isize = sizeof(struct ext4_inode) - 4438617ba13bSMingming Cao EXT4_GOOD_OLD_INODE_SIZE; 4439ac27a0ecSDave Kleikamp } else { 4440152a7b0aSTao Ma ext4_iget_extra_inode(inode, raw_inode, ei); 4441ac27a0ecSDave Kleikamp } 4442814525f4SDarrick J. Wong } 4443ac27a0ecSDave Kleikamp 4444ef7f3835SKalpak Shah EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode); 4445ef7f3835SKalpak Shah EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode); 4446ef7f3835SKalpak Shah EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode); 4447ef7f3835SKalpak Shah EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode); 4448ef7f3835SKalpak Shah 4449ed3654ebSTheodore Ts'o if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) { 445025ec56b5SJean Noel Cordenner inode->i_version = le32_to_cpu(raw_inode->i_disk_version); 445125ec56b5SJean Noel Cordenner if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { 445225ec56b5SJean Noel Cordenner if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi)) 445325ec56b5SJean Noel Cordenner inode->i_version |= 445425ec56b5SJean Noel Cordenner (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32; 445525ec56b5SJean Noel Cordenner } 4456c4f65706STheodore Ts'o } 445725ec56b5SJean Noel Cordenner 4458c4b5a614STheodore Ts'o ret = 0; 4459485c26ecSTheodore Ts'o if (ei->i_file_acl && 44601032988cSTheodore Ts'o !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) { 446124676da4STheodore Ts'o EXT4_ERROR_INODE(inode, "bad extended attribute block %llu", 446224676da4STheodore Ts'o ei->i_file_acl); 44636a797d27SDarrick J. Wong ret = -EFSCORRUPTED; 4464485c26ecSTheodore Ts'o goto bad_inode; 4465f19d5870STao Ma } else if (!ext4_has_inline_data(inode)) { 4466f19d5870STao Ma if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 4467f19d5870STao Ma if ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 4468c4b5a614STheodore Ts'o (S_ISLNK(inode->i_mode) && 4469f19d5870STao Ma !ext4_inode_is_fast_symlink(inode)))) 44707a262f7cSAneesh Kumar K.V /* Validate extent which is part of inode */ 44717a262f7cSAneesh Kumar K.V ret = ext4_ext_check_inode(inode); 4472fe2c8191SThiemo Nagel } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 4473fe2c8191SThiemo Nagel (S_ISLNK(inode->i_mode) && 4474fe2c8191SThiemo Nagel !ext4_inode_is_fast_symlink(inode))) { 4475fe2c8191SThiemo Nagel /* Validate block references which are part of inode */ 44761f7d1e77STheodore Ts'o ret = ext4_ind_check_inode(inode); 4477fe2c8191SThiemo Nagel } 4478f19d5870STao Ma } 4479567f3e9aSTheodore Ts'o if (ret) 44807a262f7cSAneesh Kumar K.V goto bad_inode; 44817a262f7cSAneesh Kumar K.V 4482ac27a0ecSDave Kleikamp if (S_ISREG(inode->i_mode)) { 4483617ba13bSMingming Cao inode->i_op = &ext4_file_inode_operations; 4484617ba13bSMingming Cao inode->i_fop = &ext4_file_operations; 4485617ba13bSMingming Cao ext4_set_aops(inode); 4486ac27a0ecSDave Kleikamp } else if (S_ISDIR(inode->i_mode)) { 4487617ba13bSMingming Cao inode->i_op = &ext4_dir_inode_operations; 4488617ba13bSMingming Cao inode->i_fop = &ext4_dir_operations; 4489ac27a0ecSDave Kleikamp } else if (S_ISLNK(inode->i_mode)) { 4490a7a67e8aSAl Viro if (ext4_encrypted_inode(inode)) { 4491a7a67e8aSAl Viro inode->i_op = &ext4_encrypted_symlink_inode_operations; 4492a7a67e8aSAl Viro ext4_set_aops(inode); 4493a7a67e8aSAl Viro } else if (ext4_inode_is_fast_symlink(inode)) { 449475e7566bSAl Viro inode->i_link = (char *)ei->i_data; 4495617ba13bSMingming Cao inode->i_op = &ext4_fast_symlink_inode_operations; 4496e83c1397SDuane Griffin nd_terminate_link(ei->i_data, inode->i_size, 4497e83c1397SDuane Griffin sizeof(ei->i_data) - 1); 4498e83c1397SDuane Griffin } else { 4499617ba13bSMingming Cao inode->i_op = &ext4_symlink_inode_operations; 4500617ba13bSMingming Cao ext4_set_aops(inode); 4501ac27a0ecSDave Kleikamp } 450221fc61c7SAl Viro inode_nohighmem(inode); 4503563bdd61STheodore Ts'o } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 4504563bdd61STheodore Ts'o S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 4505617ba13bSMingming Cao inode->i_op = &ext4_special_inode_operations; 4506ac27a0ecSDave Kleikamp if (raw_inode->i_block[0]) 4507ac27a0ecSDave Kleikamp init_special_inode(inode, inode->i_mode, 4508ac27a0ecSDave Kleikamp old_decode_dev(le32_to_cpu(raw_inode->i_block[0]))); 4509ac27a0ecSDave Kleikamp else 4510ac27a0ecSDave Kleikamp init_special_inode(inode, inode->i_mode, 4511ac27a0ecSDave Kleikamp new_decode_dev(le32_to_cpu(raw_inode->i_block[1]))); 4512393d1d1dSDr. Tilmann Bubeck } else if (ino == EXT4_BOOT_LOADER_INO) { 4513393d1d1dSDr. Tilmann Bubeck make_bad_inode(inode); 4514563bdd61STheodore Ts'o } else { 45156a797d27SDarrick J. Wong ret = -EFSCORRUPTED; 451624676da4STheodore Ts'o EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode); 4517563bdd61STheodore Ts'o goto bad_inode; 4518ac27a0ecSDave Kleikamp } 4519ac27a0ecSDave Kleikamp brelse(iloc.bh); 4520617ba13bSMingming Cao ext4_set_inode_flags(inode); 45211d1fe1eeSDavid Howells unlock_new_inode(inode); 45221d1fe1eeSDavid Howells return inode; 4523ac27a0ecSDave Kleikamp 4524ac27a0ecSDave Kleikamp bad_inode: 4525567f3e9aSTheodore Ts'o brelse(iloc.bh); 45261d1fe1eeSDavid Howells iget_failed(inode); 45271d1fe1eeSDavid Howells return ERR_PTR(ret); 4528ac27a0ecSDave Kleikamp } 4529ac27a0ecSDave Kleikamp 4530f4bb2981STheodore Ts'o struct inode *ext4_iget_normal(struct super_block *sb, unsigned long ino) 4531f4bb2981STheodore Ts'o { 4532f4bb2981STheodore Ts'o if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO) 45336a797d27SDarrick J. Wong return ERR_PTR(-EFSCORRUPTED); 4534f4bb2981STheodore Ts'o return ext4_iget(sb, ino); 4535f4bb2981STheodore Ts'o } 4536f4bb2981STheodore Ts'o 45370fc1b451SAneesh Kumar K.V static int ext4_inode_blocks_set(handle_t *handle, 45380fc1b451SAneesh Kumar K.V struct ext4_inode *raw_inode, 45390fc1b451SAneesh Kumar K.V struct ext4_inode_info *ei) 45400fc1b451SAneesh Kumar K.V { 45410fc1b451SAneesh Kumar K.V struct inode *inode = &(ei->vfs_inode); 45420fc1b451SAneesh Kumar K.V u64 i_blocks = inode->i_blocks; 45430fc1b451SAneesh Kumar K.V struct super_block *sb = inode->i_sb; 45440fc1b451SAneesh Kumar K.V 45450fc1b451SAneesh Kumar K.V if (i_blocks <= ~0U) { 45460fc1b451SAneesh Kumar K.V /* 45474907cb7bSAnatol Pomozov * i_blocks can be represented in a 32 bit variable 45480fc1b451SAneesh Kumar K.V * as multiple of 512 bytes 45490fc1b451SAneesh Kumar K.V */ 45508180a562SAneesh Kumar K.V raw_inode->i_blocks_lo = cpu_to_le32(i_blocks); 45510fc1b451SAneesh Kumar K.V raw_inode->i_blocks_high = 0; 455284a8dce2SDmitry Monakhov ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE); 4553f287a1a5STheodore Ts'o return 0; 4554f287a1a5STheodore Ts'o } 4555e2b911c5SDarrick J. Wong if (!ext4_has_feature_huge_file(sb)) 4556f287a1a5STheodore Ts'o return -EFBIG; 4557f287a1a5STheodore Ts'o 4558f287a1a5STheodore Ts'o if (i_blocks <= 0xffffffffffffULL) { 45590fc1b451SAneesh Kumar K.V /* 45600fc1b451SAneesh Kumar K.V * i_blocks can be represented in a 48 bit variable 45610fc1b451SAneesh Kumar K.V * as multiple of 512 bytes 45620fc1b451SAneesh Kumar K.V */ 45638180a562SAneesh Kumar K.V raw_inode->i_blocks_lo = cpu_to_le32(i_blocks); 45640fc1b451SAneesh Kumar K.V raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32); 456584a8dce2SDmitry Monakhov ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE); 45660fc1b451SAneesh Kumar K.V } else { 456784a8dce2SDmitry Monakhov ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE); 45688180a562SAneesh Kumar K.V /* i_block is stored in file system block size */ 45698180a562SAneesh Kumar K.V i_blocks = i_blocks >> (inode->i_blkbits - 9); 45708180a562SAneesh Kumar K.V raw_inode->i_blocks_lo = cpu_to_le32(i_blocks); 45718180a562SAneesh Kumar K.V raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32); 45720fc1b451SAneesh Kumar K.V } 4573f287a1a5STheodore Ts'o return 0; 45740fc1b451SAneesh Kumar K.V } 45750fc1b451SAneesh Kumar K.V 4576a26f4992STheodore Ts'o struct other_inode { 4577a26f4992STheodore Ts'o unsigned long orig_ino; 4578a26f4992STheodore Ts'o struct ext4_inode *raw_inode; 4579a26f4992STheodore Ts'o }; 4580a26f4992STheodore Ts'o 4581a26f4992STheodore Ts'o static int other_inode_match(struct inode * inode, unsigned long ino, 4582a26f4992STheodore Ts'o void *data) 4583a26f4992STheodore Ts'o { 4584a26f4992STheodore Ts'o struct other_inode *oi = (struct other_inode *) data; 4585a26f4992STheodore Ts'o 4586a26f4992STheodore Ts'o if ((inode->i_ino != ino) || 4587a26f4992STheodore Ts'o (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW | 4588a26f4992STheodore Ts'o I_DIRTY_SYNC | I_DIRTY_DATASYNC)) || 4589a26f4992STheodore Ts'o ((inode->i_state & I_DIRTY_TIME) == 0)) 4590a26f4992STheodore Ts'o return 0; 4591a26f4992STheodore Ts'o spin_lock(&inode->i_lock); 4592a26f4992STheodore Ts'o if (((inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW | 4593a26f4992STheodore Ts'o I_DIRTY_SYNC | I_DIRTY_DATASYNC)) == 0) && 4594a26f4992STheodore Ts'o (inode->i_state & I_DIRTY_TIME)) { 4595a26f4992STheodore Ts'o struct ext4_inode_info *ei = EXT4_I(inode); 4596a26f4992STheodore Ts'o 4597a26f4992STheodore Ts'o inode->i_state &= ~(I_DIRTY_TIME | I_DIRTY_TIME_EXPIRED); 4598a26f4992STheodore Ts'o spin_unlock(&inode->i_lock); 4599a26f4992STheodore Ts'o 4600a26f4992STheodore Ts'o spin_lock(&ei->i_raw_lock); 4601a26f4992STheodore Ts'o EXT4_INODE_SET_XTIME(i_ctime, inode, oi->raw_inode); 4602a26f4992STheodore Ts'o EXT4_INODE_SET_XTIME(i_mtime, inode, oi->raw_inode); 4603a26f4992STheodore Ts'o EXT4_INODE_SET_XTIME(i_atime, inode, oi->raw_inode); 4604a26f4992STheodore Ts'o ext4_inode_csum_set(inode, oi->raw_inode, ei); 4605a26f4992STheodore Ts'o spin_unlock(&ei->i_raw_lock); 4606a26f4992STheodore Ts'o trace_ext4_other_inode_update_time(inode, oi->orig_ino); 4607a26f4992STheodore Ts'o return -1; 4608a26f4992STheodore Ts'o } 4609a26f4992STheodore Ts'o spin_unlock(&inode->i_lock); 4610a26f4992STheodore Ts'o return -1; 4611a26f4992STheodore Ts'o } 4612a26f4992STheodore Ts'o 4613a26f4992STheodore Ts'o /* 4614a26f4992STheodore Ts'o * Opportunistically update the other time fields for other inodes in 4615a26f4992STheodore Ts'o * the same inode table block. 4616a26f4992STheodore Ts'o */ 4617a26f4992STheodore Ts'o static void ext4_update_other_inodes_time(struct super_block *sb, 4618a26f4992STheodore Ts'o unsigned long orig_ino, char *buf) 4619a26f4992STheodore Ts'o { 4620a26f4992STheodore Ts'o struct other_inode oi; 4621a26f4992STheodore Ts'o unsigned long ino; 4622a26f4992STheodore Ts'o int i, inodes_per_block = EXT4_SB(sb)->s_inodes_per_block; 4623a26f4992STheodore Ts'o int inode_size = EXT4_INODE_SIZE(sb); 4624a26f4992STheodore Ts'o 4625a26f4992STheodore Ts'o oi.orig_ino = orig_ino; 46260f0ff9a9STheodore Ts'o /* 46270f0ff9a9STheodore Ts'o * Calculate the first inode in the inode table block. Inode 46280f0ff9a9STheodore Ts'o * numbers are one-based. That is, the first inode in a block 46290f0ff9a9STheodore Ts'o * (assuming 4k blocks and 256 byte inodes) is (n*16 + 1). 46300f0ff9a9STheodore Ts'o */ 46310f0ff9a9STheodore Ts'o ino = ((orig_ino - 1) & ~(inodes_per_block - 1)) + 1; 4632a26f4992STheodore Ts'o for (i = 0; i < inodes_per_block; i++, ino++, buf += inode_size) { 4633a26f4992STheodore Ts'o if (ino == orig_ino) 4634a26f4992STheodore Ts'o continue; 4635a26f4992STheodore Ts'o oi.raw_inode = (struct ext4_inode *) buf; 4636a26f4992STheodore Ts'o (void) find_inode_nowait(sb, ino, other_inode_match, &oi); 4637a26f4992STheodore Ts'o } 4638a26f4992STheodore Ts'o } 4639a26f4992STheodore Ts'o 4640ac27a0ecSDave Kleikamp /* 4641ac27a0ecSDave Kleikamp * Post the struct inode info into an on-disk inode location in the 4642ac27a0ecSDave Kleikamp * buffer-cache. This gobbles the caller's reference to the 4643ac27a0ecSDave Kleikamp * buffer_head in the inode location struct. 4644ac27a0ecSDave Kleikamp * 4645ac27a0ecSDave Kleikamp * The caller must have write access to iloc->bh. 4646ac27a0ecSDave Kleikamp */ 4647617ba13bSMingming Cao static int ext4_do_update_inode(handle_t *handle, 4648ac27a0ecSDave Kleikamp struct inode *inode, 4649830156c7SFrank Mayhar struct ext4_iloc *iloc) 4650ac27a0ecSDave Kleikamp { 4651617ba13bSMingming Cao struct ext4_inode *raw_inode = ext4_raw_inode(iloc); 4652617ba13bSMingming Cao struct ext4_inode_info *ei = EXT4_I(inode); 4653ac27a0ecSDave Kleikamp struct buffer_head *bh = iloc->bh; 4654202ee5dfSTheodore Ts'o struct super_block *sb = inode->i_sb; 4655ac27a0ecSDave Kleikamp int err = 0, rc, block; 4656202ee5dfSTheodore Ts'o int need_datasync = 0, set_large_file = 0; 465708cefc7aSEric W. Biederman uid_t i_uid; 465808cefc7aSEric W. Biederman gid_t i_gid; 4659040cb378SLi Xi projid_t i_projid; 4660ac27a0ecSDave Kleikamp 4661202ee5dfSTheodore Ts'o spin_lock(&ei->i_raw_lock); 4662202ee5dfSTheodore Ts'o 4663202ee5dfSTheodore Ts'o /* For fields not tracked in the in-memory inode, 4664ac27a0ecSDave Kleikamp * initialise them to zero for new inodes. */ 466519f5fb7aSTheodore Ts'o if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) 4666617ba13bSMingming Cao memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size); 4667ac27a0ecSDave Kleikamp 4668ff9ddf7eSJan Kara ext4_get_inode_flags(ei); 4669ac27a0ecSDave Kleikamp raw_inode->i_mode = cpu_to_le16(inode->i_mode); 467008cefc7aSEric W. Biederman i_uid = i_uid_read(inode); 467108cefc7aSEric W. Biederman i_gid = i_gid_read(inode); 4672040cb378SLi Xi i_projid = from_kprojid(&init_user_ns, ei->i_projid); 4673ac27a0ecSDave Kleikamp if (!(test_opt(inode->i_sb, NO_UID32))) { 467408cefc7aSEric W. Biederman raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid)); 467508cefc7aSEric W. Biederman raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid)); 4676ac27a0ecSDave Kleikamp /* 4677ac27a0ecSDave Kleikamp * Fix up interoperability with old kernels. Otherwise, old inodes get 4678ac27a0ecSDave Kleikamp * re-used with the upper 16 bits of the uid/gid intact 4679ac27a0ecSDave Kleikamp */ 4680ac27a0ecSDave Kleikamp if (!ei->i_dtime) { 4681ac27a0ecSDave Kleikamp raw_inode->i_uid_high = 468208cefc7aSEric W. Biederman cpu_to_le16(high_16_bits(i_uid)); 4683ac27a0ecSDave Kleikamp raw_inode->i_gid_high = 468408cefc7aSEric W. Biederman cpu_to_le16(high_16_bits(i_gid)); 4685ac27a0ecSDave Kleikamp } else { 4686ac27a0ecSDave Kleikamp raw_inode->i_uid_high = 0; 4687ac27a0ecSDave Kleikamp raw_inode->i_gid_high = 0; 4688ac27a0ecSDave Kleikamp } 4689ac27a0ecSDave Kleikamp } else { 469008cefc7aSEric W. Biederman raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid)); 469108cefc7aSEric W. Biederman raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid)); 4692ac27a0ecSDave Kleikamp raw_inode->i_uid_high = 0; 4693ac27a0ecSDave Kleikamp raw_inode->i_gid_high = 0; 4694ac27a0ecSDave Kleikamp } 4695ac27a0ecSDave Kleikamp raw_inode->i_links_count = cpu_to_le16(inode->i_nlink); 4696ef7f3835SKalpak Shah 4697ef7f3835SKalpak Shah EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode); 4698ef7f3835SKalpak Shah EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode); 4699ef7f3835SKalpak Shah EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode); 4700ef7f3835SKalpak Shah EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode); 4701ef7f3835SKalpak Shah 4702bce92d56SLi Xi err = ext4_inode_blocks_set(handle, raw_inode, ei); 4703bce92d56SLi Xi if (err) { 4704202ee5dfSTheodore Ts'o spin_unlock(&ei->i_raw_lock); 47050fc1b451SAneesh Kumar K.V goto out_brelse; 4706202ee5dfSTheodore Ts'o } 4707ac27a0ecSDave Kleikamp raw_inode->i_dtime = cpu_to_le32(ei->i_dtime); 4708353eb83cSTheodore Ts'o raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF); 4709ed3654ebSTheodore Ts'o if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) 4710a1ddeb7eSBadari Pulavarty raw_inode->i_file_acl_high = 4711a1ddeb7eSBadari Pulavarty cpu_to_le16(ei->i_file_acl >> 32); 47127973c0c1SAneesh Kumar K.V raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl); 4713b71fc079SJan Kara if (ei->i_disksize != ext4_isize(raw_inode)) { 4714a48380f7SAneesh Kumar K.V ext4_isize_set(raw_inode, ei->i_disksize); 4715b71fc079SJan Kara need_datasync = 1; 4716b71fc079SJan Kara } 4717ac27a0ecSDave Kleikamp if (ei->i_disksize > 0x7fffffffULL) { 4718e2b911c5SDarrick J. Wong if (!ext4_has_feature_large_file(sb) || 4719617ba13bSMingming Cao EXT4_SB(sb)->s_es->s_rev_level == 4720202ee5dfSTheodore Ts'o cpu_to_le32(EXT4_GOOD_OLD_REV)) 4721202ee5dfSTheodore Ts'o set_large_file = 1; 4722ac27a0ecSDave Kleikamp } 4723ac27a0ecSDave Kleikamp raw_inode->i_generation = cpu_to_le32(inode->i_generation); 4724ac27a0ecSDave Kleikamp if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { 4725ac27a0ecSDave Kleikamp if (old_valid_dev(inode->i_rdev)) { 4726ac27a0ecSDave Kleikamp raw_inode->i_block[0] = 4727ac27a0ecSDave Kleikamp cpu_to_le32(old_encode_dev(inode->i_rdev)); 4728ac27a0ecSDave Kleikamp raw_inode->i_block[1] = 0; 4729ac27a0ecSDave Kleikamp } else { 4730ac27a0ecSDave Kleikamp raw_inode->i_block[0] = 0; 4731ac27a0ecSDave Kleikamp raw_inode->i_block[1] = 4732ac27a0ecSDave Kleikamp cpu_to_le32(new_encode_dev(inode->i_rdev)); 4733ac27a0ecSDave Kleikamp raw_inode->i_block[2] = 0; 4734ac27a0ecSDave Kleikamp } 4735f19d5870STao Ma } else if (!ext4_has_inline_data(inode)) { 4736de9a55b8STheodore Ts'o for (block = 0; block < EXT4_N_BLOCKS; block++) 4737ac27a0ecSDave Kleikamp raw_inode->i_block[block] = ei->i_data[block]; 4738f19d5870STao Ma } 4739ac27a0ecSDave Kleikamp 4740ed3654ebSTheodore Ts'o if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) { 474125ec56b5SJean Noel Cordenner raw_inode->i_disk_version = cpu_to_le32(inode->i_version); 474225ec56b5SJean Noel Cordenner if (ei->i_extra_isize) { 474325ec56b5SJean Noel Cordenner if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi)) 474425ec56b5SJean Noel Cordenner raw_inode->i_version_hi = 474525ec56b5SJean Noel Cordenner cpu_to_le32(inode->i_version >> 32); 4746c4f65706STheodore Ts'o raw_inode->i_extra_isize = 4747c4f65706STheodore Ts'o cpu_to_le16(ei->i_extra_isize); 4748c4f65706STheodore Ts'o } 474925ec56b5SJean Noel Cordenner } 4750040cb378SLi Xi 4751040cb378SLi Xi BUG_ON(!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, 4752040cb378SLi Xi EXT4_FEATURE_RO_COMPAT_PROJECT) && 4753040cb378SLi Xi i_projid != EXT4_DEF_PROJID); 4754040cb378SLi Xi 4755040cb378SLi Xi if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && 4756040cb378SLi Xi EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) 4757040cb378SLi Xi raw_inode->i_projid = cpu_to_le32(i_projid); 4758040cb378SLi Xi 4759814525f4SDarrick J. Wong ext4_inode_csum_set(inode, raw_inode, ei); 4760202ee5dfSTheodore Ts'o spin_unlock(&ei->i_raw_lock); 4761a26f4992STheodore Ts'o if (inode->i_sb->s_flags & MS_LAZYTIME) 4762a26f4992STheodore Ts'o ext4_update_other_inodes_time(inode->i_sb, inode->i_ino, 4763a26f4992STheodore Ts'o bh->b_data); 4764202ee5dfSTheodore Ts'o 47650390131bSFrank Mayhar BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata"); 476673b50c1cSCurt Wohlgemuth rc = ext4_handle_dirty_metadata(handle, NULL, bh); 4767ac27a0ecSDave Kleikamp if (!err) 4768ac27a0ecSDave Kleikamp err = rc; 476919f5fb7aSTheodore Ts'o ext4_clear_inode_state(inode, EXT4_STATE_NEW); 4770202ee5dfSTheodore Ts'o if (set_large_file) { 47715d601255Sliang xie BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get write access"); 4772202ee5dfSTheodore Ts'o err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh); 4773202ee5dfSTheodore Ts'o if (err) 4774202ee5dfSTheodore Ts'o goto out_brelse; 4775202ee5dfSTheodore Ts'o ext4_update_dynamic_rev(sb); 4776e2b911c5SDarrick J. Wong ext4_set_feature_large_file(sb); 4777202ee5dfSTheodore Ts'o ext4_handle_sync(handle); 4778202ee5dfSTheodore Ts'o err = ext4_handle_dirty_super(handle, sb); 4779202ee5dfSTheodore Ts'o } 4780b71fc079SJan Kara ext4_update_inode_fsync_trans(handle, inode, need_datasync); 4781ac27a0ecSDave Kleikamp out_brelse: 4782ac27a0ecSDave Kleikamp brelse(bh); 4783617ba13bSMingming Cao ext4_std_error(inode->i_sb, err); 4784ac27a0ecSDave Kleikamp return err; 4785ac27a0ecSDave Kleikamp } 4786ac27a0ecSDave Kleikamp 4787ac27a0ecSDave Kleikamp /* 4788617ba13bSMingming Cao * ext4_write_inode() 4789ac27a0ecSDave Kleikamp * 4790ac27a0ecSDave Kleikamp * We are called from a few places: 4791ac27a0ecSDave Kleikamp * 479287f7e416STheodore Ts'o * - Within generic_file_aio_write() -> generic_write_sync() for O_SYNC files. 4793ac27a0ecSDave Kleikamp * Here, there will be no transaction running. We wait for any running 47944907cb7bSAnatol Pomozov * transaction to commit. 4795ac27a0ecSDave Kleikamp * 479687f7e416STheodore Ts'o * - Within flush work (sys_sync(), kupdate and such). 479787f7e416STheodore Ts'o * We wait on commit, if told to. 4798ac27a0ecSDave Kleikamp * 479987f7e416STheodore Ts'o * - Within iput_final() -> write_inode_now() 480087f7e416STheodore Ts'o * We wait on commit, if told to. 4801ac27a0ecSDave Kleikamp * 4802ac27a0ecSDave Kleikamp * In all cases it is actually safe for us to return without doing anything, 4803ac27a0ecSDave Kleikamp * because the inode has been copied into a raw inode buffer in 480487f7e416STheodore Ts'o * ext4_mark_inode_dirty(). This is a correctness thing for WB_SYNC_ALL 480587f7e416STheodore Ts'o * writeback. 4806ac27a0ecSDave Kleikamp * 4807ac27a0ecSDave Kleikamp * Note that we are absolutely dependent upon all inode dirtiers doing the 4808ac27a0ecSDave Kleikamp * right thing: they *must* call mark_inode_dirty() after dirtying info in 4809ac27a0ecSDave Kleikamp * which we are interested. 4810ac27a0ecSDave Kleikamp * 4811ac27a0ecSDave Kleikamp * It would be a bug for them to not do this. The code: 4812ac27a0ecSDave Kleikamp * 4813ac27a0ecSDave Kleikamp * mark_inode_dirty(inode) 4814ac27a0ecSDave Kleikamp * stuff(); 4815ac27a0ecSDave Kleikamp * inode->i_size = expr; 4816ac27a0ecSDave Kleikamp * 481787f7e416STheodore Ts'o * is in error because write_inode() could occur while `stuff()' is running, 481887f7e416STheodore Ts'o * and the new i_size will be lost. Plus the inode will no longer be on the 481987f7e416STheodore Ts'o * superblock's dirty inode list. 4820ac27a0ecSDave Kleikamp */ 4821a9185b41SChristoph Hellwig int ext4_write_inode(struct inode *inode, struct writeback_control *wbc) 4822ac27a0ecSDave Kleikamp { 482391ac6f43SFrank Mayhar int err; 482491ac6f43SFrank Mayhar 482587f7e416STheodore Ts'o if (WARN_ON_ONCE(current->flags & PF_MEMALLOC)) 4826ac27a0ecSDave Kleikamp return 0; 4827ac27a0ecSDave Kleikamp 482891ac6f43SFrank Mayhar if (EXT4_SB(inode->i_sb)->s_journal) { 4829617ba13bSMingming Cao if (ext4_journal_current_handle()) { 4830b38bd33aSMingming Cao jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n"); 4831ac27a0ecSDave Kleikamp dump_stack(); 4832ac27a0ecSDave Kleikamp return -EIO; 4833ac27a0ecSDave Kleikamp } 4834ac27a0ecSDave Kleikamp 483510542c22SJan Kara /* 483610542c22SJan Kara * No need to force transaction in WB_SYNC_NONE mode. Also 483710542c22SJan Kara * ext4_sync_fs() will force the commit after everything is 483810542c22SJan Kara * written. 483910542c22SJan Kara */ 484010542c22SJan Kara if (wbc->sync_mode != WB_SYNC_ALL || wbc->for_sync) 4841ac27a0ecSDave Kleikamp return 0; 4842ac27a0ecSDave Kleikamp 484391ac6f43SFrank Mayhar err = ext4_force_commit(inode->i_sb); 484491ac6f43SFrank Mayhar } else { 484591ac6f43SFrank Mayhar struct ext4_iloc iloc; 484691ac6f43SFrank Mayhar 48478b472d73SCurt Wohlgemuth err = __ext4_get_inode_loc(inode, &iloc, 0); 484891ac6f43SFrank Mayhar if (err) 484991ac6f43SFrank Mayhar return err; 485010542c22SJan Kara /* 485110542c22SJan Kara * sync(2) will flush the whole buffer cache. No need to do 485210542c22SJan Kara * it here separately for each inode. 485310542c22SJan Kara */ 485410542c22SJan Kara if (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync) 4855830156c7SFrank Mayhar sync_dirty_buffer(iloc.bh); 4856830156c7SFrank Mayhar if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) { 4857c398eda0STheodore Ts'o EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr, 4858c398eda0STheodore Ts'o "IO error syncing inode"); 4859830156c7SFrank Mayhar err = -EIO; 4860830156c7SFrank Mayhar } 4861fd2dd9fbSCurt Wohlgemuth brelse(iloc.bh); 486291ac6f43SFrank Mayhar } 486391ac6f43SFrank Mayhar return err; 4864ac27a0ecSDave Kleikamp } 4865ac27a0ecSDave Kleikamp 4866ac27a0ecSDave Kleikamp /* 486753e87268SJan Kara * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate 486853e87268SJan Kara * buffers that are attached to a page stradding i_size and are undergoing 486953e87268SJan Kara * commit. In that case we have to wait for commit to finish and try again. 487053e87268SJan Kara */ 487153e87268SJan Kara static void ext4_wait_for_tail_page_commit(struct inode *inode) 487253e87268SJan Kara { 487353e87268SJan Kara struct page *page; 487453e87268SJan Kara unsigned offset; 487553e87268SJan Kara journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; 487653e87268SJan Kara tid_t commit_tid = 0; 487753e87268SJan Kara int ret; 487853e87268SJan Kara 487953e87268SJan Kara offset = inode->i_size & (PAGE_CACHE_SIZE - 1); 488053e87268SJan Kara /* 488153e87268SJan Kara * All buffers in the last page remain valid? Then there's nothing to 488253e87268SJan Kara * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE == 488353e87268SJan Kara * blocksize case 488453e87268SJan Kara */ 488553e87268SJan Kara if (offset > PAGE_CACHE_SIZE - (1 << inode->i_blkbits)) 488653e87268SJan Kara return; 488753e87268SJan Kara while (1) { 488853e87268SJan Kara page = find_lock_page(inode->i_mapping, 488953e87268SJan Kara inode->i_size >> PAGE_CACHE_SHIFT); 489053e87268SJan Kara if (!page) 489153e87268SJan Kara return; 4892ca99fdd2SLukas Czerner ret = __ext4_journalled_invalidatepage(page, offset, 4893ca99fdd2SLukas Czerner PAGE_CACHE_SIZE - offset); 489453e87268SJan Kara unlock_page(page); 489553e87268SJan Kara page_cache_release(page); 489653e87268SJan Kara if (ret != -EBUSY) 489753e87268SJan Kara return; 489853e87268SJan Kara commit_tid = 0; 489953e87268SJan Kara read_lock(&journal->j_state_lock); 490053e87268SJan Kara if (journal->j_committing_transaction) 490153e87268SJan Kara commit_tid = journal->j_committing_transaction->t_tid; 490253e87268SJan Kara read_unlock(&journal->j_state_lock); 490353e87268SJan Kara if (commit_tid) 490453e87268SJan Kara jbd2_log_wait_commit(journal, commit_tid); 490553e87268SJan Kara } 490653e87268SJan Kara } 490753e87268SJan Kara 490853e87268SJan Kara /* 4909617ba13bSMingming Cao * ext4_setattr() 4910ac27a0ecSDave Kleikamp * 4911ac27a0ecSDave Kleikamp * Called from notify_change. 4912ac27a0ecSDave Kleikamp * 4913ac27a0ecSDave Kleikamp * We want to trap VFS attempts to truncate the file as soon as 4914ac27a0ecSDave Kleikamp * possible. In particular, we want to make sure that when the VFS 4915ac27a0ecSDave Kleikamp * shrinks i_size, we put the inode on the orphan list and modify 4916ac27a0ecSDave Kleikamp * i_disksize immediately, so that during the subsequent flushing of 4917ac27a0ecSDave Kleikamp * dirty pages and freeing of disk blocks, we can guarantee that any 4918ac27a0ecSDave Kleikamp * commit will leave the blocks being flushed in an unused state on 4919ac27a0ecSDave Kleikamp * disk. (On recovery, the inode will get truncated and the blocks will 4920ac27a0ecSDave Kleikamp * be freed, so we have a strong guarantee that no future commit will 4921ac27a0ecSDave Kleikamp * leave these blocks visible to the user.) 4922ac27a0ecSDave Kleikamp * 4923678aaf48SJan Kara * Another thing we have to assure is that if we are in ordered mode 4924678aaf48SJan Kara * and inode is still attached to the committing transaction, we must 4925678aaf48SJan Kara * we start writeout of all the dirty pages which are being truncated. 4926678aaf48SJan Kara * This way we are sure that all the data written in the previous 4927678aaf48SJan Kara * transaction are already on disk (truncate waits for pages under 4928678aaf48SJan Kara * writeback). 4929678aaf48SJan Kara * 4930678aaf48SJan Kara * Called with inode->i_mutex down. 4931ac27a0ecSDave Kleikamp */ 4932617ba13bSMingming Cao int ext4_setattr(struct dentry *dentry, struct iattr *attr) 4933ac27a0ecSDave Kleikamp { 49342b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 4935ac27a0ecSDave Kleikamp int error, rc = 0; 49363d287de3SDmitry Monakhov int orphan = 0; 4937ac27a0ecSDave Kleikamp const unsigned int ia_valid = attr->ia_valid; 4938ac27a0ecSDave Kleikamp 4939ac27a0ecSDave Kleikamp error = inode_change_ok(inode, attr); 4940ac27a0ecSDave Kleikamp if (error) 4941ac27a0ecSDave Kleikamp return error; 4942ac27a0ecSDave Kleikamp 4943a7cdadeeSJan Kara if (is_quota_modification(inode, attr)) { 4944a7cdadeeSJan Kara error = dquot_initialize(inode); 4945a7cdadeeSJan Kara if (error) 4946a7cdadeeSJan Kara return error; 4947a7cdadeeSJan Kara } 494808cefc7aSEric W. Biederman if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) || 494908cefc7aSEric W. Biederman (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) { 4950ac27a0ecSDave Kleikamp handle_t *handle; 4951ac27a0ecSDave Kleikamp 4952ac27a0ecSDave Kleikamp /* (user+group)*(old+new) structure, inode write (sb, 4953ac27a0ecSDave Kleikamp * inode block, ? - but truncate inode update has it) */ 49549924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 49559924a92aSTheodore Ts'o (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) + 4956194074acSDmitry Monakhov EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3); 4957ac27a0ecSDave Kleikamp if (IS_ERR(handle)) { 4958ac27a0ecSDave Kleikamp error = PTR_ERR(handle); 4959ac27a0ecSDave Kleikamp goto err_out; 4960ac27a0ecSDave Kleikamp } 4961b43fa828SChristoph Hellwig error = dquot_transfer(inode, attr); 4962ac27a0ecSDave Kleikamp if (error) { 4963617ba13bSMingming Cao ext4_journal_stop(handle); 4964ac27a0ecSDave Kleikamp return error; 4965ac27a0ecSDave Kleikamp } 4966ac27a0ecSDave Kleikamp /* Update corresponding info in inode so that everything is in 4967ac27a0ecSDave Kleikamp * one transaction */ 4968ac27a0ecSDave Kleikamp if (attr->ia_valid & ATTR_UID) 4969ac27a0ecSDave Kleikamp inode->i_uid = attr->ia_uid; 4970ac27a0ecSDave Kleikamp if (attr->ia_valid & ATTR_GID) 4971ac27a0ecSDave Kleikamp inode->i_gid = attr->ia_gid; 4972617ba13bSMingming Cao error = ext4_mark_inode_dirty(handle, inode); 4973617ba13bSMingming Cao ext4_journal_stop(handle); 4974ac27a0ecSDave Kleikamp } 4975ac27a0ecSDave Kleikamp 49763da40c7bSJosef Bacik if (attr->ia_valid & ATTR_SIZE) { 49775208386cSJan Kara handle_t *handle; 49783da40c7bSJosef Bacik loff_t oldsize = inode->i_size; 49793da40c7bSJosef Bacik int shrink = (attr->ia_size <= inode->i_size); 4980562c72aaSChristoph Hellwig 498112e9b892SDmitry Monakhov if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { 4982e2b46574SEric Sandeen struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 4983e2b46574SEric Sandeen 49840c095c7fSTheodore Ts'o if (attr->ia_size > sbi->s_bitmap_maxbytes) 49850c095c7fSTheodore Ts'o return -EFBIG; 4986e2b46574SEric Sandeen } 49873da40c7bSJosef Bacik if (!S_ISREG(inode->i_mode)) 49883da40c7bSJosef Bacik return -EINVAL; 4989dff6efc3SChristoph Hellwig 4990dff6efc3SChristoph Hellwig if (IS_I_VERSION(inode) && attr->ia_size != inode->i_size) 4991dff6efc3SChristoph Hellwig inode_inc_iversion(inode); 4992dff6efc3SChristoph Hellwig 49933da40c7bSJosef Bacik if (ext4_should_order_data(inode) && 4994072bd7eaSTheodore Ts'o (attr->ia_size < inode->i_size)) { 49955208386cSJan Kara error = ext4_begin_ordered_truncate(inode, 49965208386cSJan Kara attr->ia_size); 49975208386cSJan Kara if (error) 49985208386cSJan Kara goto err_out; 49995208386cSJan Kara } 50003da40c7bSJosef Bacik if (attr->ia_size != inode->i_size) { 50019924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_INODE, 3); 5002ac27a0ecSDave Kleikamp if (IS_ERR(handle)) { 5003ac27a0ecSDave Kleikamp error = PTR_ERR(handle); 5004ac27a0ecSDave Kleikamp goto err_out; 5005ac27a0ecSDave Kleikamp } 50063da40c7bSJosef Bacik if (ext4_handle_valid(handle) && shrink) { 5007617ba13bSMingming Cao error = ext4_orphan_add(handle, inode); 50083d287de3SDmitry Monakhov orphan = 1; 50093d287de3SDmitry Monakhov } 5010911af577SEryu Guan /* 5011911af577SEryu Guan * Update c/mtime on truncate up, ext4_truncate() will 5012911af577SEryu Guan * update c/mtime in shrink case below 5013911af577SEryu Guan */ 5014911af577SEryu Guan if (!shrink) { 5015911af577SEryu Guan inode->i_mtime = ext4_current_time(inode); 5016911af577SEryu Guan inode->i_ctime = inode->i_mtime; 5017911af577SEryu Guan } 501890e775b7SJan Kara down_write(&EXT4_I(inode)->i_data_sem); 5019617ba13bSMingming Cao EXT4_I(inode)->i_disksize = attr->ia_size; 5020617ba13bSMingming Cao rc = ext4_mark_inode_dirty(handle, inode); 5021ac27a0ecSDave Kleikamp if (!error) 5022ac27a0ecSDave Kleikamp error = rc; 502390e775b7SJan Kara /* 502490e775b7SJan Kara * We have to update i_size under i_data_sem together 502590e775b7SJan Kara * with i_disksize to avoid races with writeback code 502690e775b7SJan Kara * running ext4_wb_update_i_disksize(). 502790e775b7SJan Kara */ 502890e775b7SJan Kara if (!error) 502990e775b7SJan Kara i_size_write(inode, attr->ia_size); 503090e775b7SJan Kara up_write(&EXT4_I(inode)->i_data_sem); 5031617ba13bSMingming Cao ext4_journal_stop(handle); 5032678aaf48SJan Kara if (error) { 50333da40c7bSJosef Bacik if (orphan) 5034678aaf48SJan Kara ext4_orphan_del(NULL, inode); 5035678aaf48SJan Kara goto err_out; 5036678aaf48SJan Kara } 5037d6320cbfSJan Kara } 50383da40c7bSJosef Bacik if (!shrink) 50393da40c7bSJosef Bacik pagecache_isize_extended(inode, oldsize, inode->i_size); 504090e775b7SJan Kara 504153e87268SJan Kara /* 504253e87268SJan Kara * Blocks are going to be removed from the inode. Wait 504353e87268SJan Kara * for dio in flight. Temporarily disable 504453e87268SJan Kara * dioread_nolock to prevent livelock. 504553e87268SJan Kara */ 50461b65007eSDmitry Monakhov if (orphan) { 504753e87268SJan Kara if (!ext4_should_journal_data(inode)) { 50481b65007eSDmitry Monakhov ext4_inode_block_unlocked_dio(inode); 50491c9114f9SDmitry Monakhov inode_dio_wait(inode); 50501b65007eSDmitry Monakhov ext4_inode_resume_unlocked_dio(inode); 505153e87268SJan Kara } else 505253e87268SJan Kara ext4_wait_for_tail_page_commit(inode); 50531b65007eSDmitry Monakhov } 5054ea3d7209SJan Kara down_write(&EXT4_I(inode)->i_mmap_sem); 505553e87268SJan Kara /* 505653e87268SJan Kara * Truncate pagecache after we've waited for commit 505753e87268SJan Kara * in data=journal mode to make pages freeable. 505853e87268SJan Kara */ 50597caef267SKirill A. Shutemov truncate_pagecache(inode, inode->i_size); 50603da40c7bSJosef Bacik if (shrink) 5061072bd7eaSTheodore Ts'o ext4_truncate(inode); 5062ea3d7209SJan Kara up_write(&EXT4_I(inode)->i_mmap_sem); 50633da40c7bSJosef Bacik } 5064ac27a0ecSDave Kleikamp 50651025774cSChristoph Hellwig if (!rc) { 50661025774cSChristoph Hellwig setattr_copy(inode, attr); 50671025774cSChristoph Hellwig mark_inode_dirty(inode); 50681025774cSChristoph Hellwig } 50691025774cSChristoph Hellwig 50701025774cSChristoph Hellwig /* 50711025774cSChristoph Hellwig * If the call to ext4_truncate failed to get a transaction handle at 50721025774cSChristoph Hellwig * all, we need to clean up the in-core orphan list manually. 50731025774cSChristoph Hellwig */ 50743d287de3SDmitry Monakhov if (orphan && inode->i_nlink) 5075617ba13bSMingming Cao ext4_orphan_del(NULL, inode); 5076ac27a0ecSDave Kleikamp 5077ac27a0ecSDave Kleikamp if (!rc && (ia_valid & ATTR_MODE)) 507864e178a7SChristoph Hellwig rc = posix_acl_chmod(inode, inode->i_mode); 5079ac27a0ecSDave Kleikamp 5080ac27a0ecSDave Kleikamp err_out: 5081617ba13bSMingming Cao ext4_std_error(inode->i_sb, error); 5082ac27a0ecSDave Kleikamp if (!error) 5083ac27a0ecSDave Kleikamp error = rc; 5084ac27a0ecSDave Kleikamp return error; 5085ac27a0ecSDave Kleikamp } 5086ac27a0ecSDave Kleikamp 50873e3398a0SMingming Cao int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry, 50883e3398a0SMingming Cao struct kstat *stat) 50893e3398a0SMingming Cao { 50903e3398a0SMingming Cao struct inode *inode; 50918af8eeccSJan Kara unsigned long long delalloc_blocks; 50923e3398a0SMingming Cao 50932b0143b5SDavid Howells inode = d_inode(dentry); 50943e3398a0SMingming Cao generic_fillattr(inode, stat); 50953e3398a0SMingming Cao 50963e3398a0SMingming Cao /* 50979206c561SAndreas Dilger * If there is inline data in the inode, the inode will normally not 50989206c561SAndreas Dilger * have data blocks allocated (it may have an external xattr block). 50999206c561SAndreas Dilger * Report at least one sector for such files, so tools like tar, rsync, 51009206c561SAndreas Dilger * others doen't incorrectly think the file is completely sparse. 51019206c561SAndreas Dilger */ 51029206c561SAndreas Dilger if (unlikely(ext4_has_inline_data(inode))) 51039206c561SAndreas Dilger stat->blocks += (stat->size + 511) >> 9; 51049206c561SAndreas Dilger 51059206c561SAndreas Dilger /* 51063e3398a0SMingming Cao * We can't update i_blocks if the block allocation is delayed 51073e3398a0SMingming Cao * otherwise in the case of system crash before the real block 51083e3398a0SMingming Cao * allocation is done, we will have i_blocks inconsistent with 51093e3398a0SMingming Cao * on-disk file blocks. 51103e3398a0SMingming Cao * We always keep i_blocks updated together with real 51113e3398a0SMingming Cao * allocation. But to not confuse with user, stat 51123e3398a0SMingming Cao * will return the blocks that include the delayed allocation 51133e3398a0SMingming Cao * blocks for this file. 51143e3398a0SMingming Cao */ 511596607551STao Ma delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb), 511696607551STao Ma EXT4_I(inode)->i_reserved_data_blocks); 51178af8eeccSJan Kara stat->blocks += delalloc_blocks << (inode->i_sb->s_blocksize_bits - 9); 51183e3398a0SMingming Cao return 0; 51193e3398a0SMingming Cao } 5120ac27a0ecSDave Kleikamp 5121fffb2739SJan Kara static int ext4_index_trans_blocks(struct inode *inode, int lblocks, 5122fffb2739SJan Kara int pextents) 5123a02908f1SMingming Cao { 512412e9b892SDmitry Monakhov if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 5125fffb2739SJan Kara return ext4_ind_trans_blocks(inode, lblocks); 5126fffb2739SJan Kara return ext4_ext_index_trans_blocks(inode, pextents); 5127a02908f1SMingming Cao } 5128ac51d837STheodore Ts'o 5129a02908f1SMingming Cao /* 5130a02908f1SMingming Cao * Account for index blocks, block groups bitmaps and block group 5131a02908f1SMingming Cao * descriptor blocks if modify datablocks and index blocks 5132a02908f1SMingming Cao * worse case, the indexs blocks spread over different block groups 5133a02908f1SMingming Cao * 5134a02908f1SMingming Cao * If datablocks are discontiguous, they are possible to spread over 51354907cb7bSAnatol Pomozov * different block groups too. If they are contiguous, with flexbg, 5136a02908f1SMingming Cao * they could still across block group boundary. 5137a02908f1SMingming Cao * 5138a02908f1SMingming Cao * Also account for superblock, inode, quota and xattr blocks 5139a02908f1SMingming Cao */ 5140fffb2739SJan Kara static int ext4_meta_trans_blocks(struct inode *inode, int lblocks, 5141fffb2739SJan Kara int pextents) 5142a02908f1SMingming Cao { 51438df9675fSTheodore Ts'o ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb); 51448df9675fSTheodore Ts'o int gdpblocks; 5145a02908f1SMingming Cao int idxblocks; 5146a02908f1SMingming Cao int ret = 0; 5147a02908f1SMingming Cao 5148a02908f1SMingming Cao /* 5149fffb2739SJan Kara * How many index blocks need to touch to map @lblocks logical blocks 5150fffb2739SJan Kara * to @pextents physical extents? 5151a02908f1SMingming Cao */ 5152fffb2739SJan Kara idxblocks = ext4_index_trans_blocks(inode, lblocks, pextents); 5153a02908f1SMingming Cao 5154a02908f1SMingming Cao ret = idxblocks; 5155a02908f1SMingming Cao 5156a02908f1SMingming Cao /* 5157a02908f1SMingming Cao * Now let's see how many group bitmaps and group descriptors need 5158a02908f1SMingming Cao * to account 5159a02908f1SMingming Cao */ 5160fffb2739SJan Kara groups = idxblocks + pextents; 5161a02908f1SMingming Cao gdpblocks = groups; 51628df9675fSTheodore Ts'o if (groups > ngroups) 51638df9675fSTheodore Ts'o groups = ngroups; 5164a02908f1SMingming Cao if (groups > EXT4_SB(inode->i_sb)->s_gdb_count) 5165a02908f1SMingming Cao gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count; 5166a02908f1SMingming Cao 5167a02908f1SMingming Cao /* bitmaps and block group descriptor blocks */ 5168a02908f1SMingming Cao ret += groups + gdpblocks; 5169a02908f1SMingming Cao 5170a02908f1SMingming Cao /* Blocks for super block, inode, quota and xattr blocks */ 5171a02908f1SMingming Cao ret += EXT4_META_TRANS_BLOCKS(inode->i_sb); 5172ac27a0ecSDave Kleikamp 5173ac27a0ecSDave Kleikamp return ret; 5174ac27a0ecSDave Kleikamp } 5175ac27a0ecSDave Kleikamp 5176ac27a0ecSDave Kleikamp /* 517725985edcSLucas De Marchi * Calculate the total number of credits to reserve to fit 5178f3bd1f3fSMingming Cao * the modification of a single pages into a single transaction, 5179f3bd1f3fSMingming Cao * which may include multiple chunks of block allocations. 5180a02908f1SMingming Cao * 5181525f4ed8SMingming Cao * This could be called via ext4_write_begin() 5182a02908f1SMingming Cao * 5183525f4ed8SMingming Cao * We need to consider the worse case, when 5184a02908f1SMingming Cao * one new block per extent. 5185a02908f1SMingming Cao */ 5186a02908f1SMingming Cao int ext4_writepage_trans_blocks(struct inode *inode) 5187a02908f1SMingming Cao { 5188a02908f1SMingming Cao int bpp = ext4_journal_blocks_per_page(inode); 5189a02908f1SMingming Cao int ret; 5190a02908f1SMingming Cao 5191fffb2739SJan Kara ret = ext4_meta_trans_blocks(inode, bpp, bpp); 5192a02908f1SMingming Cao 5193a02908f1SMingming Cao /* Account for data blocks for journalled mode */ 5194a02908f1SMingming Cao if (ext4_should_journal_data(inode)) 5195a02908f1SMingming Cao ret += bpp; 5196a02908f1SMingming Cao return ret; 5197a02908f1SMingming Cao } 5198f3bd1f3fSMingming Cao 5199f3bd1f3fSMingming Cao /* 5200f3bd1f3fSMingming Cao * Calculate the journal credits for a chunk of data modification. 5201f3bd1f3fSMingming Cao * 5202f3bd1f3fSMingming Cao * This is called from DIO, fallocate or whoever calling 520379e83036SEric Sandeen * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks. 5204f3bd1f3fSMingming Cao * 5205f3bd1f3fSMingming Cao * journal buffers for data blocks are not included here, as DIO 5206f3bd1f3fSMingming Cao * and fallocate do no need to journal data buffers. 5207f3bd1f3fSMingming Cao */ 5208f3bd1f3fSMingming Cao int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks) 5209f3bd1f3fSMingming Cao { 5210f3bd1f3fSMingming Cao return ext4_meta_trans_blocks(inode, nrblocks, 1); 5211f3bd1f3fSMingming Cao } 5212f3bd1f3fSMingming Cao 5213a02908f1SMingming Cao /* 5214617ba13bSMingming Cao * The caller must have previously called ext4_reserve_inode_write(). 5215ac27a0ecSDave Kleikamp * Give this, we know that the caller already has write access to iloc->bh. 5216ac27a0ecSDave Kleikamp */ 5217617ba13bSMingming Cao int ext4_mark_iloc_dirty(handle_t *handle, 5218617ba13bSMingming Cao struct inode *inode, struct ext4_iloc *iloc) 5219ac27a0ecSDave Kleikamp { 5220ac27a0ecSDave Kleikamp int err = 0; 5221ac27a0ecSDave Kleikamp 5222c64db50eSTheodore Ts'o if (IS_I_VERSION(inode)) 522325ec56b5SJean Noel Cordenner inode_inc_iversion(inode); 522425ec56b5SJean Noel Cordenner 5225ac27a0ecSDave Kleikamp /* the do_update_inode consumes one bh->b_count */ 5226ac27a0ecSDave Kleikamp get_bh(iloc->bh); 5227ac27a0ecSDave Kleikamp 5228dab291afSMingming Cao /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */ 5229830156c7SFrank Mayhar err = ext4_do_update_inode(handle, inode, iloc); 5230ac27a0ecSDave Kleikamp put_bh(iloc->bh); 5231ac27a0ecSDave Kleikamp return err; 5232ac27a0ecSDave Kleikamp } 5233ac27a0ecSDave Kleikamp 5234ac27a0ecSDave Kleikamp /* 5235ac27a0ecSDave Kleikamp * On success, We end up with an outstanding reference count against 5236ac27a0ecSDave Kleikamp * iloc->bh. This _must_ be cleaned up later. 5237ac27a0ecSDave Kleikamp */ 5238ac27a0ecSDave Kleikamp 5239ac27a0ecSDave Kleikamp int 5240617ba13bSMingming Cao ext4_reserve_inode_write(handle_t *handle, struct inode *inode, 5241617ba13bSMingming Cao struct ext4_iloc *iloc) 5242ac27a0ecSDave Kleikamp { 52430390131bSFrank Mayhar int err; 52440390131bSFrank Mayhar 5245617ba13bSMingming Cao err = ext4_get_inode_loc(inode, iloc); 5246ac27a0ecSDave Kleikamp if (!err) { 5247ac27a0ecSDave Kleikamp BUFFER_TRACE(iloc->bh, "get_write_access"); 5248617ba13bSMingming Cao err = ext4_journal_get_write_access(handle, iloc->bh); 5249ac27a0ecSDave Kleikamp if (err) { 5250ac27a0ecSDave Kleikamp brelse(iloc->bh); 5251ac27a0ecSDave Kleikamp iloc->bh = NULL; 5252ac27a0ecSDave Kleikamp } 5253ac27a0ecSDave Kleikamp } 5254617ba13bSMingming Cao ext4_std_error(inode->i_sb, err); 5255ac27a0ecSDave Kleikamp return err; 5256ac27a0ecSDave Kleikamp } 5257ac27a0ecSDave Kleikamp 5258ac27a0ecSDave Kleikamp /* 52596dd4ee7cSKalpak Shah * Expand an inode by new_extra_isize bytes. 52606dd4ee7cSKalpak Shah * Returns 0 on success or negative error number on failure. 52616dd4ee7cSKalpak Shah */ 52621d03ec98SAneesh Kumar K.V static int ext4_expand_extra_isize(struct inode *inode, 52631d03ec98SAneesh Kumar K.V unsigned int new_extra_isize, 52641d03ec98SAneesh Kumar K.V struct ext4_iloc iloc, 52651d03ec98SAneesh Kumar K.V handle_t *handle) 52666dd4ee7cSKalpak Shah { 52676dd4ee7cSKalpak Shah struct ext4_inode *raw_inode; 52686dd4ee7cSKalpak Shah struct ext4_xattr_ibody_header *header; 52696dd4ee7cSKalpak Shah 52706dd4ee7cSKalpak Shah if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) 52716dd4ee7cSKalpak Shah return 0; 52726dd4ee7cSKalpak Shah 52736dd4ee7cSKalpak Shah raw_inode = ext4_raw_inode(&iloc); 52746dd4ee7cSKalpak Shah 52756dd4ee7cSKalpak Shah header = IHDR(inode, raw_inode); 52766dd4ee7cSKalpak Shah 52776dd4ee7cSKalpak Shah /* No extended attributes present */ 527819f5fb7aSTheodore Ts'o if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) || 52796dd4ee7cSKalpak Shah header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) { 52806dd4ee7cSKalpak Shah memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0, 52816dd4ee7cSKalpak Shah new_extra_isize); 52826dd4ee7cSKalpak Shah EXT4_I(inode)->i_extra_isize = new_extra_isize; 52836dd4ee7cSKalpak Shah return 0; 52846dd4ee7cSKalpak Shah } 52856dd4ee7cSKalpak Shah 52866dd4ee7cSKalpak Shah /* try to expand with EAs present */ 52876dd4ee7cSKalpak Shah return ext4_expand_extra_isize_ea(inode, new_extra_isize, 52886dd4ee7cSKalpak Shah raw_inode, handle); 52896dd4ee7cSKalpak Shah } 52906dd4ee7cSKalpak Shah 52916dd4ee7cSKalpak Shah /* 5292ac27a0ecSDave Kleikamp * What we do here is to mark the in-core inode as clean with respect to inode 5293ac27a0ecSDave Kleikamp * dirtiness (it may still be data-dirty). 5294ac27a0ecSDave Kleikamp * This means that the in-core inode may be reaped by prune_icache 5295ac27a0ecSDave Kleikamp * without having to perform any I/O. This is a very good thing, 5296ac27a0ecSDave Kleikamp * because *any* task may call prune_icache - even ones which 5297ac27a0ecSDave Kleikamp * have a transaction open against a different journal. 5298ac27a0ecSDave Kleikamp * 5299ac27a0ecSDave Kleikamp * Is this cheating? Not really. Sure, we haven't written the 5300ac27a0ecSDave Kleikamp * inode out, but prune_icache isn't a user-visible syncing function. 5301ac27a0ecSDave Kleikamp * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync) 5302ac27a0ecSDave Kleikamp * we start and wait on commits. 5303ac27a0ecSDave Kleikamp */ 5304617ba13bSMingming Cao int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode) 5305ac27a0ecSDave Kleikamp { 5306617ba13bSMingming Cao struct ext4_iloc iloc; 53076dd4ee7cSKalpak Shah struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 53086dd4ee7cSKalpak Shah static unsigned int mnt_count; 53096dd4ee7cSKalpak Shah int err, ret; 5310ac27a0ecSDave Kleikamp 5311ac27a0ecSDave Kleikamp might_sleep(); 53127ff9c073STheodore Ts'o trace_ext4_mark_inode_dirty(inode, _RET_IP_); 5313617ba13bSMingming Cao err = ext4_reserve_inode_write(handle, inode, &iloc); 53140390131bSFrank Mayhar if (ext4_handle_valid(handle) && 53150390131bSFrank Mayhar EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize && 531619f5fb7aSTheodore Ts'o !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) { 53176dd4ee7cSKalpak Shah /* 53186dd4ee7cSKalpak Shah * We need extra buffer credits since we may write into EA block 53196dd4ee7cSKalpak Shah * with this same handle. If journal_extend fails, then it will 53206dd4ee7cSKalpak Shah * only result in a minor loss of functionality for that inode. 53216dd4ee7cSKalpak Shah * If this is felt to be critical, then e2fsck should be run to 53226dd4ee7cSKalpak Shah * force a large enough s_min_extra_isize. 53236dd4ee7cSKalpak Shah */ 53246dd4ee7cSKalpak Shah if ((jbd2_journal_extend(handle, 53256dd4ee7cSKalpak Shah EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) { 53266dd4ee7cSKalpak Shah ret = ext4_expand_extra_isize(inode, 53276dd4ee7cSKalpak Shah sbi->s_want_extra_isize, 53286dd4ee7cSKalpak Shah iloc, handle); 53296dd4ee7cSKalpak Shah if (ret) { 533019f5fb7aSTheodore Ts'o ext4_set_inode_state(inode, 533119f5fb7aSTheodore Ts'o EXT4_STATE_NO_EXPAND); 5332c1bddad9SAneesh Kumar K.V if (mnt_count != 5333c1bddad9SAneesh Kumar K.V le16_to_cpu(sbi->s_es->s_mnt_count)) { 533412062dddSEric Sandeen ext4_warning(inode->i_sb, 53356dd4ee7cSKalpak Shah "Unable to expand inode %lu. Delete" 53366dd4ee7cSKalpak Shah " some EAs or run e2fsck.", 53376dd4ee7cSKalpak Shah inode->i_ino); 5338c1bddad9SAneesh Kumar K.V mnt_count = 5339c1bddad9SAneesh Kumar K.V le16_to_cpu(sbi->s_es->s_mnt_count); 53406dd4ee7cSKalpak Shah } 53416dd4ee7cSKalpak Shah } 53426dd4ee7cSKalpak Shah } 53436dd4ee7cSKalpak Shah } 5344ac27a0ecSDave Kleikamp if (!err) 5345617ba13bSMingming Cao err = ext4_mark_iloc_dirty(handle, inode, &iloc); 5346ac27a0ecSDave Kleikamp return err; 5347ac27a0ecSDave Kleikamp } 5348ac27a0ecSDave Kleikamp 5349ac27a0ecSDave Kleikamp /* 5350617ba13bSMingming Cao * ext4_dirty_inode() is called from __mark_inode_dirty() 5351ac27a0ecSDave Kleikamp * 5352ac27a0ecSDave Kleikamp * We're really interested in the case where a file is being extended. 5353ac27a0ecSDave Kleikamp * i_size has been changed by generic_commit_write() and we thus need 5354ac27a0ecSDave Kleikamp * to include the updated inode in the current transaction. 5355ac27a0ecSDave Kleikamp * 53565dd4056dSChristoph Hellwig * Also, dquot_alloc_block() will always dirty the inode when blocks 5357ac27a0ecSDave Kleikamp * are allocated to the file. 5358ac27a0ecSDave Kleikamp * 5359ac27a0ecSDave Kleikamp * If the inode is marked synchronous, we don't honour that here - doing 5360ac27a0ecSDave Kleikamp * so would cause a commit on atime updates, which we don't bother doing. 5361ac27a0ecSDave Kleikamp * We handle synchronous inodes at the highest possible level. 53620ae45f63STheodore Ts'o * 53630ae45f63STheodore Ts'o * If only the I_DIRTY_TIME flag is set, we can skip everything. If 53640ae45f63STheodore Ts'o * I_DIRTY_TIME and I_DIRTY_SYNC is set, the only inode fields we need 53650ae45f63STheodore Ts'o * to copy into the on-disk inode structure are the timestamp files. 5366ac27a0ecSDave Kleikamp */ 5367aa385729SChristoph Hellwig void ext4_dirty_inode(struct inode *inode, int flags) 5368ac27a0ecSDave Kleikamp { 5369ac27a0ecSDave Kleikamp handle_t *handle; 5370ac27a0ecSDave Kleikamp 53710ae45f63STheodore Ts'o if (flags == I_DIRTY_TIME) 53720ae45f63STheodore Ts'o return; 53739924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_INODE, 2); 5374ac27a0ecSDave Kleikamp if (IS_ERR(handle)) 5375ac27a0ecSDave Kleikamp goto out; 5376f3dc272fSCurt Wohlgemuth 5377617ba13bSMingming Cao ext4_mark_inode_dirty(handle, inode); 5378f3dc272fSCurt Wohlgemuth 5379617ba13bSMingming Cao ext4_journal_stop(handle); 5380ac27a0ecSDave Kleikamp out: 5381ac27a0ecSDave Kleikamp return; 5382ac27a0ecSDave Kleikamp } 5383ac27a0ecSDave Kleikamp 5384ac27a0ecSDave Kleikamp #if 0 5385ac27a0ecSDave Kleikamp /* 5386ac27a0ecSDave Kleikamp * Bind an inode's backing buffer_head into this transaction, to prevent 5387ac27a0ecSDave Kleikamp * it from being flushed to disk early. Unlike 5388617ba13bSMingming Cao * ext4_reserve_inode_write, this leaves behind no bh reference and 5389ac27a0ecSDave Kleikamp * returns no iloc structure, so the caller needs to repeat the iloc 5390ac27a0ecSDave Kleikamp * lookup to mark the inode dirty later. 5391ac27a0ecSDave Kleikamp */ 5392617ba13bSMingming Cao static int ext4_pin_inode(handle_t *handle, struct inode *inode) 5393ac27a0ecSDave Kleikamp { 5394617ba13bSMingming Cao struct ext4_iloc iloc; 5395ac27a0ecSDave Kleikamp 5396ac27a0ecSDave Kleikamp int err = 0; 5397ac27a0ecSDave Kleikamp if (handle) { 5398617ba13bSMingming Cao err = ext4_get_inode_loc(inode, &iloc); 5399ac27a0ecSDave Kleikamp if (!err) { 5400ac27a0ecSDave Kleikamp BUFFER_TRACE(iloc.bh, "get_write_access"); 5401dab291afSMingming Cao err = jbd2_journal_get_write_access(handle, iloc.bh); 5402ac27a0ecSDave Kleikamp if (!err) 54030390131bSFrank Mayhar err = ext4_handle_dirty_metadata(handle, 540473b50c1cSCurt Wohlgemuth NULL, 5405ac27a0ecSDave Kleikamp iloc.bh); 5406ac27a0ecSDave Kleikamp brelse(iloc.bh); 5407ac27a0ecSDave Kleikamp } 5408ac27a0ecSDave Kleikamp } 5409617ba13bSMingming Cao ext4_std_error(inode->i_sb, err); 5410ac27a0ecSDave Kleikamp return err; 5411ac27a0ecSDave Kleikamp } 5412ac27a0ecSDave Kleikamp #endif 5413ac27a0ecSDave Kleikamp 5414617ba13bSMingming Cao int ext4_change_inode_journal_flag(struct inode *inode, int val) 5415ac27a0ecSDave Kleikamp { 5416ac27a0ecSDave Kleikamp journal_t *journal; 5417ac27a0ecSDave Kleikamp handle_t *handle; 5418ac27a0ecSDave Kleikamp int err; 5419ac27a0ecSDave Kleikamp 5420ac27a0ecSDave Kleikamp /* 5421ac27a0ecSDave Kleikamp * We have to be very careful here: changing a data block's 5422ac27a0ecSDave Kleikamp * journaling status dynamically is dangerous. If we write a 5423ac27a0ecSDave Kleikamp * data block to the journal, change the status and then delete 5424ac27a0ecSDave Kleikamp * that block, we risk forgetting to revoke the old log record 5425ac27a0ecSDave Kleikamp * from the journal and so a subsequent replay can corrupt data. 5426ac27a0ecSDave Kleikamp * So, first we make sure that the journal is empty and that 5427ac27a0ecSDave Kleikamp * nobody is changing anything. 5428ac27a0ecSDave Kleikamp */ 5429ac27a0ecSDave Kleikamp 5430617ba13bSMingming Cao journal = EXT4_JOURNAL(inode); 54310390131bSFrank Mayhar if (!journal) 54320390131bSFrank Mayhar return 0; 5433d699594dSDave Hansen if (is_journal_aborted(journal)) 5434ac27a0ecSDave Kleikamp return -EROFS; 54352aff57b0SYongqiang Yang /* We have to allocate physical blocks for delalloc blocks 54362aff57b0SYongqiang Yang * before flushing journal. otherwise delalloc blocks can not 54372aff57b0SYongqiang Yang * be allocated any more. even more truncate on delalloc blocks 54382aff57b0SYongqiang Yang * could trigger BUG by flushing delalloc blocks in journal. 54392aff57b0SYongqiang Yang * There is no delalloc block in non-journal data mode. 54402aff57b0SYongqiang Yang */ 54412aff57b0SYongqiang Yang if (val && test_opt(inode->i_sb, DELALLOC)) { 54422aff57b0SYongqiang Yang err = ext4_alloc_da_blocks(inode); 54432aff57b0SYongqiang Yang if (err < 0) 54442aff57b0SYongqiang Yang return err; 54452aff57b0SYongqiang Yang } 5446ac27a0ecSDave Kleikamp 544717335dccSDmitry Monakhov /* Wait for all existing dio workers */ 544817335dccSDmitry Monakhov ext4_inode_block_unlocked_dio(inode); 544917335dccSDmitry Monakhov inode_dio_wait(inode); 545017335dccSDmitry Monakhov 5451dab291afSMingming Cao jbd2_journal_lock_updates(journal); 5452ac27a0ecSDave Kleikamp 5453ac27a0ecSDave Kleikamp /* 5454ac27a0ecSDave Kleikamp * OK, there are no updates running now, and all cached data is 5455ac27a0ecSDave Kleikamp * synced to disk. We are now in a completely consistent state 5456ac27a0ecSDave Kleikamp * which doesn't have anything in the journal, and we know that 5457ac27a0ecSDave Kleikamp * no filesystem updates are running, so it is safe to modify 5458ac27a0ecSDave Kleikamp * the inode's in-core data-journaling state flag now. 5459ac27a0ecSDave Kleikamp */ 5460ac27a0ecSDave Kleikamp 5461ac27a0ecSDave Kleikamp if (val) 546212e9b892SDmitry Monakhov ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA); 54635872ddaaSYongqiang Yang else { 54644f879ca6SJan Kara err = jbd2_journal_flush(journal); 54654f879ca6SJan Kara if (err < 0) { 54664f879ca6SJan Kara jbd2_journal_unlock_updates(journal); 54674f879ca6SJan Kara ext4_inode_resume_unlocked_dio(inode); 54684f879ca6SJan Kara return err; 54694f879ca6SJan Kara } 547012e9b892SDmitry Monakhov ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA); 54715872ddaaSYongqiang Yang } 5472617ba13bSMingming Cao ext4_set_aops(inode); 5473ac27a0ecSDave Kleikamp 5474dab291afSMingming Cao jbd2_journal_unlock_updates(journal); 547517335dccSDmitry Monakhov ext4_inode_resume_unlocked_dio(inode); 5476ac27a0ecSDave Kleikamp 5477ac27a0ecSDave Kleikamp /* Finally we can mark the inode as dirty. */ 5478ac27a0ecSDave Kleikamp 54799924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 5480ac27a0ecSDave Kleikamp if (IS_ERR(handle)) 5481ac27a0ecSDave Kleikamp return PTR_ERR(handle); 5482ac27a0ecSDave Kleikamp 5483617ba13bSMingming Cao err = ext4_mark_inode_dirty(handle, inode); 54840390131bSFrank Mayhar ext4_handle_sync(handle); 5485617ba13bSMingming Cao ext4_journal_stop(handle); 5486617ba13bSMingming Cao ext4_std_error(inode->i_sb, err); 5487ac27a0ecSDave Kleikamp 5488ac27a0ecSDave Kleikamp return err; 5489ac27a0ecSDave Kleikamp } 54902e9ee850SAneesh Kumar K.V 54912e9ee850SAneesh Kumar K.V static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh) 54922e9ee850SAneesh Kumar K.V { 54932e9ee850SAneesh Kumar K.V return !buffer_mapped(bh); 54942e9ee850SAneesh Kumar K.V } 54952e9ee850SAneesh Kumar K.V 5496c2ec175cSNick Piggin int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 54972e9ee850SAneesh Kumar K.V { 5498c2ec175cSNick Piggin struct page *page = vmf->page; 54992e9ee850SAneesh Kumar K.V loff_t size; 55002e9ee850SAneesh Kumar K.V unsigned long len; 55019ea7df53SJan Kara int ret; 55022e9ee850SAneesh Kumar K.V struct file *file = vma->vm_file; 5503496ad9aaSAl Viro struct inode *inode = file_inode(file); 55042e9ee850SAneesh Kumar K.V struct address_space *mapping = inode->i_mapping; 55059ea7df53SJan Kara handle_t *handle; 55069ea7df53SJan Kara get_block_t *get_block; 55079ea7df53SJan Kara int retries = 0; 55082e9ee850SAneesh Kumar K.V 55098e8ad8a5SJan Kara sb_start_pagefault(inode->i_sb); 5510041bbb6dSTheodore Ts'o file_update_time(vma->vm_file); 5511ea3d7209SJan Kara 5512ea3d7209SJan Kara down_read(&EXT4_I(inode)->i_mmap_sem); 55139ea7df53SJan Kara /* Delalloc case is easy... */ 55149ea7df53SJan Kara if (test_opt(inode->i_sb, DELALLOC) && 55159ea7df53SJan Kara !ext4_should_journal_data(inode) && 55169ea7df53SJan Kara !ext4_nonda_switch(inode->i_sb)) { 55179ea7df53SJan Kara do { 55185c500029SRoss Zwisler ret = block_page_mkwrite(vma, vmf, 55199ea7df53SJan Kara ext4_da_get_block_prep); 55209ea7df53SJan Kara } while (ret == -ENOSPC && 55219ea7df53SJan Kara ext4_should_retry_alloc(inode->i_sb, &retries)); 55229ea7df53SJan Kara goto out_ret; 55232e9ee850SAneesh Kumar K.V } 55240e499890SDarrick J. Wong 55250e499890SDarrick J. Wong lock_page(page); 55269ea7df53SJan Kara size = i_size_read(inode); 55279ea7df53SJan Kara /* Page got truncated from under us? */ 55289ea7df53SJan Kara if (page->mapping != mapping || page_offset(page) > size) { 55299ea7df53SJan Kara unlock_page(page); 55309ea7df53SJan Kara ret = VM_FAULT_NOPAGE; 55319ea7df53SJan Kara goto out; 55320e499890SDarrick J. Wong } 55332e9ee850SAneesh Kumar K.V 55342e9ee850SAneesh Kumar K.V if (page->index == size >> PAGE_CACHE_SHIFT) 55352e9ee850SAneesh Kumar K.V len = size & ~PAGE_CACHE_MASK; 55362e9ee850SAneesh Kumar K.V else 55372e9ee850SAneesh Kumar K.V len = PAGE_CACHE_SIZE; 5538a827eaffSAneesh Kumar K.V /* 55399ea7df53SJan Kara * Return if we have all the buffers mapped. This avoids the need to do 55409ea7df53SJan Kara * journal_start/journal_stop which can block and take a long time 5541a827eaffSAneesh Kumar K.V */ 55422e9ee850SAneesh Kumar K.V if (page_has_buffers(page)) { 5543f19d5870STao Ma if (!ext4_walk_page_buffers(NULL, page_buffers(page), 5544f19d5870STao Ma 0, len, NULL, 5545a827eaffSAneesh Kumar K.V ext4_bh_unmapped)) { 55469ea7df53SJan Kara /* Wait so that we don't change page under IO */ 55471d1d1a76SDarrick J. Wong wait_for_stable_page(page); 55489ea7df53SJan Kara ret = VM_FAULT_LOCKED; 55499ea7df53SJan Kara goto out; 55502e9ee850SAneesh Kumar K.V } 5551a827eaffSAneesh Kumar K.V } 5552a827eaffSAneesh Kumar K.V unlock_page(page); 55539ea7df53SJan Kara /* OK, we need to fill the hole... */ 55549ea7df53SJan Kara if (ext4_should_dioread_nolock(inode)) 5555705965bdSJan Kara get_block = ext4_get_block_unwritten; 55569ea7df53SJan Kara else 55579ea7df53SJan Kara get_block = ext4_get_block; 55589ea7df53SJan Kara retry_alloc: 55599924a92aSTheodore Ts'o handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 55609924a92aSTheodore Ts'o ext4_writepage_trans_blocks(inode)); 55619ea7df53SJan Kara if (IS_ERR(handle)) { 5562c2ec175cSNick Piggin ret = VM_FAULT_SIGBUS; 55639ea7df53SJan Kara goto out; 55649ea7df53SJan Kara } 55655c500029SRoss Zwisler ret = block_page_mkwrite(vma, vmf, get_block); 55669ea7df53SJan Kara if (!ret && ext4_should_journal_data(inode)) { 5567f19d5870STao Ma if (ext4_walk_page_buffers(handle, page_buffers(page), 0, 55689ea7df53SJan Kara PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) { 55699ea7df53SJan Kara unlock_page(page); 55709ea7df53SJan Kara ret = VM_FAULT_SIGBUS; 5571fcbb5515SYongqiang Yang ext4_journal_stop(handle); 55729ea7df53SJan Kara goto out; 55739ea7df53SJan Kara } 55749ea7df53SJan Kara ext4_set_inode_state(inode, EXT4_STATE_JDATA); 55759ea7df53SJan Kara } 55769ea7df53SJan Kara ext4_journal_stop(handle); 55779ea7df53SJan Kara if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) 55789ea7df53SJan Kara goto retry_alloc; 55799ea7df53SJan Kara out_ret: 55809ea7df53SJan Kara ret = block_page_mkwrite_return(ret); 55819ea7df53SJan Kara out: 5582ea3d7209SJan Kara up_read(&EXT4_I(inode)->i_mmap_sem); 55838e8ad8a5SJan Kara sb_end_pagefault(inode->i_sb); 55842e9ee850SAneesh Kumar K.V return ret; 55852e9ee850SAneesh Kumar K.V } 5586ea3d7209SJan Kara 5587ea3d7209SJan Kara int ext4_filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 5588ea3d7209SJan Kara { 5589ea3d7209SJan Kara struct inode *inode = file_inode(vma->vm_file); 5590ea3d7209SJan Kara int err; 5591ea3d7209SJan Kara 5592ea3d7209SJan Kara down_read(&EXT4_I(inode)->i_mmap_sem); 5593ea3d7209SJan Kara err = filemap_fault(vma, vmf); 5594ea3d7209SJan Kara up_read(&EXT4_I(inode)->i_mmap_sem); 5595ea3d7209SJan Kara 5596ea3d7209SJan Kara return err; 5597ea3d7209SJan Kara } 5598