1 files changed, 55 insertions, 26 deletions

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index ae44916d40e2..3131747199e1 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -51,25 +51,31 @@ static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw,
                               struct ext4_inode_info *ei)
 {
         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
-        __u16 csum_lo;
-        __u16 csum_hi = 0;
         __u32 csum;
+        __u16 dummy_csum = 0;
+        int offset = offsetof(struct ext4_inode, i_checksum_lo);
+        unsigned int csum_size = sizeof(dummy_csum);
 
-        csum_lo = le16_to_cpu(raw->i_checksum_lo);
-        raw->i_checksum_lo = 0;
-        if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
-            EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) {
-                csum_hi = le16_to_cpu(raw->i_checksum_hi);
-                raw->i_checksum_hi = 0;
-        }
-
-        csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)raw,
-                           EXT4_INODE_SIZE(inode->i_sb));
+        csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)raw, offset);
+        csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, csum_size);
+        offset += csum_size;
+        csum = ext4_chksum(sbi, csum, (__u8 *)raw + offset,
+                           EXT4_GOOD_OLD_INODE_SIZE - offset);
 
-        raw->i_checksum_lo = cpu_to_le16(csum_lo);
-        if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
-            EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
-                raw->i_checksum_hi = cpu_to_le16(csum_hi);
+        if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
+                offset = offsetof(struct ext4_inode, i_checksum_hi);
+                csum = ext4_chksum(sbi, csum, (__u8 *)raw +
+                                   EXT4_GOOD_OLD_INODE_SIZE,
+                                   offset - EXT4_GOOD_OLD_INODE_SIZE);
+                if (EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) {
+                        csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum,
+                                           csum_size);
+                        offset += csum_size;
+                        csum = ext4_chksum(sbi, csum, (__u8 *)raw + offset,
+                                           EXT4_INODE_SIZE(inode->i_sb) -
+                                           offset);
+                }
+        }
 
         return csum;
 }
@@ -205,9 +211,9 @@ void ext4_evict_inode(struct inode *inode)
                  * Note that directories do not have this problem because they
                  * don't use page cache.
                  */
-                if (ext4_should_journal_data(inode) &&
-                    (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode)) &&
-                    inode->i_ino != EXT4_JOURNAL_INO) {
+                if (inode->i_ino != EXT4_JOURNAL_INO &&
+                    ext4_should_journal_data(inode) &&
+                    (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode))) {
                         journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
                         tid_t commit_tid = EXT4_I(inode)->i_datasync_tid;
 
@@ -386,7 +392,7 @@ int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
         int ret;
 
         if (ext4_encrypted_inode(inode))
-                return ext4_encrypted_zeroout(inode, lblk, pblk, len);
+                return fscrypt_zeroout_range(inode, lblk, pblk, len);
 
         ret = sb_issue_zeroout(inode->i_sb, pblk, len, GFP_NOFS);
         if (ret > 0)
@@ -1152,7 +1158,7 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
         if (unlikely(err))
                 page_zero_new_buffers(page, from, to);
         else if (decrypt)
-                err = ext4_decrypt(page);
+                err = fscrypt_decrypt_page(page);
         return err;
 }
 #endif
@@ -2748,13 +2754,36 @@ retry:
                                 done = true;
                         }
                 }
-                ext4_journal_stop(handle);
+                /*
+                 * Caution: If the handle is synchronous,
+                 * ext4_journal_stop() can wait for transaction commit
+                 * to finish which may depend on writeback of pages to
+                 * complete or on page lock to be released.  In that
+                 * case, we have to wait until after after we have
+                 * submitted all the IO, released page locks we hold,
+                 * and dropped io_end reference (for extent conversion
+                 * to be able to complete) before stopping the handle.
+                 */
+                if (!ext4_handle_valid(handle) || handle->h_sync == 0) {
+                        ext4_journal_stop(handle);
+                        handle = NULL;
+                }
                 /* Submit prepared bio */
                 ext4_io_submit(&mpd.io_submit);
                 /* Unlock pages we didn't use */
                 mpage_release_unused_pages(&mpd, give_up_on_write);
-                /* Drop our io_end reference we got from init */
-                ext4_put_io_end(mpd.io_submit.io_end);
+                /*
+                 * Drop our io_end reference we got from init. We have
+                 * to be careful and use deferred io_end finishing if
+                 * we are still holding the transaction as we can
+                 * release the last reference to io_end which may end
+                 * up doing unwritten extent conversion.
+                 */
+                if (handle) {
+                        ext4_put_io_end_defer(mpd.io_submit.io_end);
+                        ext4_journal_stop(handle);
+                } else
+                        ext4_put_io_end(mpd.io_submit.io_end);
 
                 if (ret == -ENOSPC && sbi->s_journal) {
                         /*
@@ -3706,9 +3735,9 @@ static int __ext4_block_zero_page_range(handle_t *handle,
                 if (S_ISREG(inode->i_mode) &&
                     ext4_encrypted_inode(inode)) {
                         /* We expect the key to be set. */
-                        BUG_ON(!ext4_has_encryption_key(inode));
+                        BUG_ON(!fscrypt_has_encryption_key(inode));
                         BUG_ON(blocksize != PAGE_SIZE);
-                        WARN_ON_ONCE(ext4_decrypt(page));
+                        WARN_ON_ONCE(fscrypt_decrypt_page(page));
                 }
         }
         if (ext4_should_journal_data(inode)) {