Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4

Pull ext4 updates from Ted Ts'o:
 "Added new ext4 debugging ioctls to allow userspace to get information
  about the state of the extent status cache.

  Dropped workaround for pre-1970 dates which were encoded incorrectly
  in pre-4.4 kernels. Since both the kernel correctly generates, and
  e2fsck detects and fixes this issue for the past four years, it'e time
  to drop the workaround. (Also, it's not like files with dates in the
  distant past were all that common in the first place.)

  A lot of miscellaneous bug fixes and cleanups, including some ext4
  Documentation fixes. Also included are two minor bug fixes in
  fs/unicode"

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (21 commits)
  unicode: make array 'token' static const, makes object smaller
  unicode: Move static keyword to the front of declarations
  ext4: add missing bigalloc documentation.
  ext4: fix kernel oops caused by spurious casefold flag
  ext4: fix integer overflow when calculating commit interval
  ext4: use percpu_counters for extent_status cache hits/misses
  ext4: fix potential use after free after remounting with noblock_validity
  jbd2: add missing tracepoint for reserved handle
  ext4: fix punch hole for inline_data file systems
  ext4: rework reserved cluster accounting when invalidating pages
  ext4: documentation fixes
  ext4: treat buffers with write errors as containing valid data
  ext4: fix warning inside ext4_convert_unwritten_extents_endio
  ext4: set error return correctly when ext4_htree_store_dirent fails
  ext4: drop legacy pre-1970 encoding workaround
  ext4: add new ioctl EXT4_IOC_GET_ES_CACHE
  ext4: add a new ioctl EXT4_IOC_GETSTATE
  ext4: add a new ioctl EXT4_IOC_CLEAR_ES_CACHE
  jbd2: flush_descriptor(): Do not decrease buffer head's ref count
  ext4: remove unnecessary error check
  ...

1 files changed, 27 insertions, 76 deletions

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index d0dc0e3463db..123e3dee7733 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -527,7 +527,7 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
                 return -EFSCORRUPTED;
 
         /* Lookup extent status tree firstly */
-        if (ext4_es_lookup_extent(inode, map->m_lblk, &es)) {
+        if (ext4_es_lookup_extent(inode, map->m_lblk, NULL, &es)) {
                 if (ext4_es_is_written(&es) || ext4_es_is_unwritten(&es)) {
                         map->m_pblk = ext4_es_pblock(&es) +
                                         map->m_lblk - es.es_lblk;
@@ -695,7 +695,7 @@ found:
                  * extent status tree.
                  */
                 if ((flags & EXT4_GET_BLOCKS_PRE_IO) &&
-                    ext4_es_lookup_extent(inode, map->m_lblk, &es)) {
+                    ext4_es_lookup_extent(inode, map->m_lblk, NULL, &es)) {
                         if (ext4_es_is_written(&es))
                                 goto out_sem;
                 }
@@ -1024,7 +1024,7 @@ struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
         bh = ext4_getblk(handle, inode, block, map_flags);
         if (IS_ERR(bh))
                 return bh;
-        if (!bh || buffer_uptodate(bh))
+        if (!bh || ext4_buffer_uptodate(bh))
                 return bh;
         ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1, &bh);
         wait_on_buffer(bh);
@@ -1051,7 +1051,7 @@ int ext4_bread_batch(struct inode *inode, ext4_lblk_t block, int bh_count,
 
         for (i = 0; i < bh_count; i++)
                 /* Note that NULL bhs[i] is valid because of holes. */
-                if (bhs[i] && !buffer_uptodate(bhs[i]))
+                if (bhs[i] && !ext4_buffer_uptodate(bhs[i]))
                         ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1,
                                     &bhs[i]);
 
@@ -1656,49 +1656,6 @@ void ext4_da_release_space(struct inode *inode, int to_free)
         dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
 }
 
-static void ext4_da_page_release_reservation(struct page *page,
-                                             unsigned int offset,
-                                             unsigned int length)
-{
-        int contiguous_blks = 0;
-        struct buffer_head *head, *bh;
-        unsigned int curr_off = 0;
-        struct inode *inode = page->mapping->host;
-        unsigned int stop = offset + length;
-        ext4_fsblk_t lblk;
-
-        BUG_ON(stop > PAGE_SIZE || stop < length);
-
-        head = page_buffers(page);
-        bh = head;
-        do {
-                unsigned int next_off = curr_off + bh->b_size;
-
-                if (next_off > stop)
-                        break;
-
-                if ((offset <= curr_off) && (buffer_delay(bh))) {
-                        contiguous_blks++;
-                        clear_buffer_delay(bh);
-                } else if (contiguous_blks) {
-                        lblk = page->index <<
-                               (PAGE_SHIFT - inode->i_blkbits);
-                        lblk += (curr_off >> inode->i_blkbits) -
-                                contiguous_blks;
-                        ext4_es_remove_blks(inode, lblk, contiguous_blks);
-                        contiguous_blks = 0;
-                }
-                curr_off = next_off;
-        } while ((bh = bh->b_this_page) != head);
-
-        if (contiguous_blks) {
-                lblk = page->index << (PAGE_SHIFT - inode->i_blkbits);
-                lblk += (curr_off >> inode->i_blkbits) - contiguous_blks;
-                ext4_es_remove_blks(inode, lblk, contiguous_blks);
-        }
-
-}
-
 /*
  * Delayed allocation stuff
  */
@@ -1878,7 +1835,7 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
                   (unsigned long) map->m_lblk);
 
         /* Lookup extent status tree firstly */
-        if (ext4_es_lookup_extent(inode, iblock, &es)) {
+        if (ext4_es_lookup_extent(inode, iblock, NULL, &es)) {
                 if (ext4_es_is_hole(&es)) {
                         retval = 0;
                         down_read(&EXT4_I(inode)->i_data_sem);
@@ -2800,15 +2757,6 @@ static int ext4_writepages(struct address_space *mapping,
                 goto out_writepages;
         }
 
-        if (ext4_should_dioread_nolock(inode)) {
-                /*
-                 * We may need to convert up to one extent per block in
-                 * the page and we may dirty the inode.
-                 */
-                rsv_blocks = 1 + ext4_chunk_trans_blocks(inode,
-                                                PAGE_SIZE >> inode->i_blkbits);
-        }
-
         /*
          * If we have inline data and arrive here, it means that
          * we will soon create the block for the 1st page, so
@@ -2827,6 +2775,15 @@ static int ext4_writepages(struct address_space *mapping,
                 ext4_journal_stop(handle);
         }
 
+        if (ext4_should_dioread_nolock(inode)) {
+                /*
+                 * We may need to convert up to one extent per block in
+                 * the page and we may dirty the inode.
+                 */
+                rsv_blocks = 1 + ext4_chunk_trans_blocks(inode,
+                                                PAGE_SIZE >> inode->i_blkbits);
+        }
+
         if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
                 range_whole = 1;
 
@@ -3242,24 +3199,6 @@ static int ext4_da_write_end(struct file *file,
         return ret ? ret : copied;
 }
 
-static void ext4_da_invalidatepage(struct page *page, unsigned int offset,
-                                   unsigned int length)
-{
-        /*
-         * Drop reserved blocks
-         */
-        BUG_ON(!PageLocked(page));
-        if (!page_has_buffers(page))
-                goto out;
-
-        ext4_da_page_release_reservation(page, offset, length);
-
-out:
-        ext4_invalidatepage(page, offset, length);
-
-        return;
-}
-
 /*
  * Force all delayed allocation blocks to be allocated for a given inode.
  */
@@ -4002,7 +3941,7 @@ static const struct address_space_operations ext4_da_aops = {
         .write_end              = ext4_da_write_end,
         .set_page_dirty         = ext4_set_page_dirty,
         .bmap                   = ext4_bmap,
-        .invalidatepage         = ext4_da_invalidatepage,
+        .invalidatepage         = ext4_invalidatepage,
         .releasepage            = ext4_releasepage,
         .direct_IO              = ext4_direct_IO,
         .migratepage            = buffer_migrate_page,
@@ -4314,6 +4253,15 @@ int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length)
 
         trace_ext4_punch_hole(inode, offset, length, 0);
 
+        ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
+        if (ext4_has_inline_data(inode)) {
+                down_write(&EXT4_I(inode)->i_mmap_sem);
+                ret = ext4_convert_inline_data(inode);
+                up_write(&EXT4_I(inode)->i_mmap_sem);
+                if (ret)
+                        return ret;
+        }
+
         /*
          * Write out all dirty pages to avoid race conditions
          * Then release them.
@@ -5137,6 +5085,9 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
                                  "iget: bogus i_mode (%o)", inode->i_mode);
                 goto bad_inode;
         }
+        if (IS_CASEFOLDED(inode) && !ext4_has_feature_casefold(inode->i_sb))
+                ext4_error_inode(inode, function, line, 0,
+                                 "casefold flag without casefold feature");
         brelse(iloc.bh);
 
         unlock_new_inode(inode);