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

Pull ext4 update from Ted Ts'o:
 "Lots of bug fixes, cleanups and optimizations.  In the bug fixes
  category, of note is a fix for on-line resizing file systems where the
  block size is smaller than the page size (i.e., file systems 1k blocks
  on x86, or more interestingly file systems with 4k blocks on Power or
  ia64 systems.)

  In the cleanup category, the ext4's punch hole implementation was
  significantly improved by Lukas Czerner, and now supports bigalloc
  file systems.  In addition, Jan Kara significantly cleaned up the
  write submission code path.  We also improved error checking and added
  a few sanity checks.

  In the optimizations category, two major optimizations deserve
  mention.  The first is that ext4_writepages() is now used for
  nodelalloc and ext3 compatibility mode.  This allows writes to be
  submitted much more efficiently as a single bio request, instead of
  being sent as individual 4k writes into the block layer (which then
  relied on the elevator code to coalesce the requests in the block
  queue).  Secondly, the extent cache shrink mechanism, which was
  introduce in 3.9, no longer has a scalability bottleneck caused by the
  i_es_lru spinlock.  Other optimizations include some changes to reduce
  CPU usage and to avoid issuing empty commits unnecessarily."

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (86 commits)
  ext4: optimize starting extent in ext4_ext_rm_leaf()
  jbd2: invalidate handle if jbd2_journal_restart() fails
  ext4: translate flag bits to strings in tracepoints
  ext4: fix up error handling for mpage_map_and_submit_extent()
  jbd2: fix theoretical race in jbd2__journal_restart
  ext4: only zero partial blocks in ext4_zero_partial_blocks()
  ext4: check error return from ext4_write_inline_data_end()
  ext4: delete unnecessary C statements
  ext3,ext4: don't mess with dir_file->f_pos in htree_dirblock_to_tree()
  jbd2: move superblock checksum calculation to jbd2_write_superblock()
  ext4: pass inode pointer instead of file pointer to punch hole
  ext4: improve free space calculation for inline_data
  ext4: reduce object size when !CONFIG_PRINTK
  ext4: improve extent cache shrink mechanism to avoid to burn CPU time
  ext4: implement error handling of ext4_mb_new_preallocation()
  ext4: fix corruption when online resizing a fs with 1K block size
  ext4: delete unused variables
  ext4: return FIEMAP_EXTENT_UNKNOWN for delalloc extents
  jbd2: remove debug dependency on debug_fs and update Kconfig help text
  jbd2: use a single printk for jbd_debug()
  ...

2 files changed, 82 insertions, 37 deletions

diff --git a/mm/readahead.c b/mm/readahead.c
index daed28dd5830..829a77c62834 100644
--- a/mm/readahead.c
+++ b/mm/readahead.c
@@ -48,7 +48,7 @@ static void read_cache_pages_invalidate_page(struct address_space *mapping,
                 if (!trylock_page(page))
                         BUG();
                 page->mapping = mapping;
-                do_invalidatepage(page, 0);
+                do_invalidatepage(page, 0, PAGE_CACHE_SIZE);
                 page->mapping = NULL;
                 unlock_page(page);
         }
diff --git a/mm/truncate.c b/mm/truncate.c
index c75b736e54b7..e2e8a8a7eb9d 100644
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -26,7 +26,8 @@
 /**
  * do_invalidatepage - invalidate part or all of a page
  * @page: the page which is affected
- * @offset: the index of the truncation point
+ * @offset: start of the range to invalidate
+ * @length: length of the range to invalidate
  *
  * do_invalidatepage() is called when all or part of the page has become
  * invalidated by a truncate operation.
@@ -37,24 +38,18 @@
  * point.  Because the caller is about to free (and possibly reuse) those
  * blocks on-disk.
  */
-void do_invalidatepage(struct page *page, unsigned long offset)
+void do_invalidatepage(struct page *page, unsigned int offset,
+                       unsigned int length)
 {
-        void (*invalidatepage)(struct page *, unsigned long);
+        void (*invalidatepage)(struct page *, unsigned int, unsigned int);
+
         invalidatepage = page->mapping->a_ops->invalidatepage;
 #ifdef CONFIG_BLOCK
         if (!invalidatepage)
                 invalidatepage = block_invalidatepage;
 #endif
         if (invalidatepage)
-                (*invalidatepage)(page, offset);
-}
-
-static inline void truncate_partial_page(struct page *page, unsigned partial)
-{
-        zero_user_segment(page, partial, PAGE_CACHE_SIZE);
-        cleancache_invalidate_page(page->mapping, page);
-        if (page_has_private(page))
-                do_invalidatepage(page, partial);
+                (*invalidatepage)(page, offset, length);
 }
 
 /*
@@ -103,7 +98,7 @@ truncate_complete_page(struct address_space *mapping, struct page *page)
                 return -EIO;
 
         if (page_has_private(page))
-                do_invalidatepage(page, 0);
+                do_invalidatepage(page, 0, PAGE_CACHE_SIZE);
 
         cancel_dirty_page(page, PAGE_CACHE_SIZE);
 
@@ -185,11 +180,11 @@ int invalidate_inode_page(struct page *page)
  * truncate_inode_pages_range - truncate range of pages specified by start & end byte offsets
  * @mapping: mapping to truncate
  * @lstart: offset from which to truncate
- * @lend: offset to which to truncate
+ * @lend: offset to which to truncate (inclusive)
  *
  * Truncate the page cache, removing the pages that are between
- * specified offsets (and zeroing out partial page
- * (if lstart is not page aligned)).
+ * specified offsets (and zeroing out partial pages
+ * if lstart or lend + 1 is not page aligned).
  *
  * Truncate takes two passes - the first pass is nonblocking.  It will not
  * block on page locks and it will not block on writeback.  The second pass
@@ -200,35 +195,58 @@ int invalidate_inode_page(struct page *page)
  * We pass down the cache-hot hint to the page freeing code.  Even if the
  * mapping is large, it is probably the case that the final pages are the most
  * recently touched, and freeing happens in ascending file offset order.
+ *
+ * Note that since ->invalidatepage() accepts range to invalidate
+ * truncate_inode_pages_range is able to handle cases where lend + 1 is not
+ * page aligned properly.
  */
 void truncate_inode_pages_range(struct address_space *mapping,
                                 loff_t lstart, loff_t lend)
 {
-        const pgoff_t start = (lstart + PAGE_CACHE_SIZE-1) >> PAGE_CACHE_SHIFT;
-        const unsigned partial = lstart & (PAGE_CACHE_SIZE - 1);
-        struct pagevec pvec;
-        pgoff_t index;
-        pgoff_t end;
-        int i;
+        pgoff_t         start;          /* inclusive */
+        pgoff_t         end;            /* exclusive */
+        unsigned int    partial_start;  /* inclusive */
+        unsigned int    partial_end;    /* exclusive */
+        struct pagevec  pvec;
+        pgoff_t         index;
+        int             i;
 
         cleancache_invalidate_inode(mapping);
         if (mapping->nrpages == 0)
                 return;
 
-        BUG_ON((lend & (PAGE_CACHE_SIZE - 1)) != (PAGE_CACHE_SIZE - 1));
-        end = (lend >> PAGE_CACHE_SHIFT);
+        /* Offsets within partial pages */
+        partial_start = lstart & (PAGE_CACHE_SIZE - 1);
+        partial_end = (lend + 1) & (PAGE_CACHE_SIZE - 1);
+
+        /*
+         * 'start' and 'end' always covers the range of pages to be fully
+         * truncated. Partial pages are covered with 'partial_start' at the
+         * start of the range and 'partial_end' at the end of the range.
+         * Note that 'end' is exclusive while 'lend' is inclusive.
+         */
+        start = (lstart + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+        if (lend == -1)
+                /*
+                 * lend == -1 indicates end-of-file so we have to set 'end'
+                 * to the highest possible pgoff_t and since the type is
+                 * unsigned we're using -1.
+                 */
+                end = -1;
+        else
+                end = (lend + 1) >> PAGE_CACHE_SHIFT;
 
         pagevec_init(&pvec, 0);
         index = start;
-        while (index <= end && pagevec_lookup(&pvec, mapping, index,
-                        min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1)) {
+        while (index < end && pagevec_lookup(&pvec, mapping, index,
+                        min(end - index, (pgoff_t)PAGEVEC_SIZE))) {
                 mem_cgroup_uncharge_start();
                 for (i = 0; i < pagevec_count(&pvec); i++) {
                         struct page *page = pvec.pages[i];
 
                         /* We rely upon deletion not changing page->index */
                         index = page->index;
-                        if (index > end)
+                        if (index >= end)
                                 break;
 
                         if (!trylock_page(page))
@@ -247,27 +265,56 @@ void truncate_inode_pages_range(struct address_space *mapping,
                 index++;
         }
 
-        if (partial) {
+        if (partial_start) {
                 struct page *page = find_lock_page(mapping, start - 1);
                 if (page) {
+                        unsigned int top = PAGE_CACHE_SIZE;
+                        if (start > end) {
+                                /* Truncation within a single page */
+                                top = partial_end;
+                                partial_end = 0;
+                        }
                         wait_on_page_writeback(page);
-                        truncate_partial_page(page, partial);
+                        zero_user_segment(page, partial_start, top);
+                        cleancache_invalidate_page(mapping, page);
+                        if (page_has_private(page))
+                                do_invalidatepage(page, partial_start,
+                                                  top - partial_start);
                         unlock_page(page);
                         page_cache_release(page);
                 }
         }
+        if (partial_end) {
+                struct page *page = find_lock_page(mapping, end);
+                if (page) {
+                        wait_on_page_writeback(page);
+                        zero_user_segment(page, 0, partial_end);
+                        cleancache_invalidate_page(mapping, page);
+                        if (page_has_private(page))
+                                do_invalidatepage(page, 0,
+                                                  partial_end);
+                        unlock_page(page);
+                        page_cache_release(page);
+                }
+        }
+        /*
+         * If the truncation happened within a single page no pages
+         * will be released, just zeroed, so we can bail out now.
+         */
+        if (start >= end)
+                return;
 
         index = start;
         for ( ; ; ) {
                 cond_resched();
                 if (!pagevec_lookup(&pvec, mapping, index,
-                        min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1)) {
+                        min(end - index, (pgoff_t)PAGEVEC_SIZE))) {
                         if (index == start)
                                 break;
                         index = start;
                         continue;
                 }
-                if (index == start && pvec.pages[0]->index > end) {
+                if (index == start && pvec.pages[0]->index >= end) {
                         pagevec_release(&pvec);
                         break;
                 }
@@ -277,7 +324,7 @@ void truncate_inode_pages_range(struct address_space *mapping,
 
                         /* We rely upon deletion not changing page->index */
                         index = page->index;
-                        if (index > end)
+                        if (index >= end)
                                 break;
 
                         lock_page(page);
@@ -598,10 +645,8 @@ void truncate_pagecache_range(struct inode *inode, loff_t lstart, loff_t lend)
          * This rounding is currently just for example: unmap_mapping_range
          * expands its hole outwards, whereas we want it to contract the hole
          * inwards.  However, existing callers of truncate_pagecache_range are
-         * doing their own page rounding first; and truncate_inode_pages_range
-         * currently BUGs if lend is not pagealigned-1 (it handles partial
-         * page at start of hole, but not partial page at end of hole).  Note
-         * unmap_mapping_range allows holelen 0 for all, and we allow lend -1.
+         * doing their own page rounding first.  Note that unmap_mapping_range
+         * allows holelen 0 for all, and we allow lend -1 for end of file.
          */
 
         /*