--- initial
+++ final
@@ -1,139 +1,139 @@
 void truncate_inode_pages_range(struct address_space *mapping, loff_t lstart, loff_t lend) {
   pgoff_t start;              /* inclusive */
   pgoff_t end;                /* exclusive */
   unsigned int partial_start; /* inclusive */
   unsigned int partial_end;   /* exclusive */
   struct pagevec pvec;
   pgoff_t indices[PAGEVEC_SIZE];
   pgoff_t index;
   int i;
   if (mapping->nrpages == 0 && mapping->nrexceptional == 0) goto out;
   /* Offsets within partial pages */
   partial_start = lstart & (PAGE_SIZE - 1);
   partial_end = (lend + 1) & (PAGE_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_SIZE - 1) >> PAGE_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_SHIFT;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   index = start;
   while (index < end && pagevec_lookup_entries(&pvec, mapping, index, min(end - index, (pgoff_t)PAGEVEC_SIZE), indices)) {
     /*
      * Pagevec array has exceptional entries and we may also fail
      * to lock some pages. So we store pages that can be deleted
      * in a new pagevec.
      */
     struct pagevec locked_pvec;
-    pagevec_init(&locked_pvec, 0);
+    pagevec_init(&locked_pvec);
     for (i = 0; i < pagevec_count(&pvec); i++) {
       struct page *page = pvec.pages[i];
       /* We rely upon deletion not changing page->index */
       index = indices[i];
       if (index >= end) break;
       if (radix_tree_exceptional_entry(page)) continue;
       if (!trylock_page(page)) continue;
       WARN_ON(page_to_index(page) != index);
       if (PageWriteback(page)) {
         unlock_page(page);
         continue;
       }
       if (page->mapping != mapping) {
         unlock_page(page);
         continue;
       }
       pagevec_add(&locked_pvec, page);
     }
     for (i = 0; i < pagevec_count(&locked_pvec); i++)
       truncate_cleanup_page(mapping, locked_pvec.pages[i]);
     delete_from_page_cache_batch(mapping, &locked_pvec);
     for (i = 0; i < pagevec_count(&locked_pvec); i++)
       unlock_page(locked_pvec.pages[i]);
     truncate_exceptional_pvec_entries(mapping, &pvec, indices, end);
     pagevec_release(&pvec);
     cond_resched();
     index++;
   }
   if (partial_start) {
     struct page *page = find_lock_page(mapping, start - 1);
     if (page) {
       unsigned int top = PAGE_SIZE;
       if (start > end) {
         /* Truncation within a single page */
         top = partial_end;
         partial_end = 0;
       }
       wait_on_page_writeback(page);
       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);
       put_page(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);
       put_page(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) goto out;
   index = start;
   for (;;) {
     cond_resched();
     if (!pagevec_lookup_entries(&pvec, mapping, index, min(end - index, (pgoff_t)PAGEVEC_SIZE), indices)) {
       /* If all gone from start onwards, we're done */
       if (index == start) break;
       /* Otherwise restart to make sure all gone */
       index = start;
       continue;
     }
     if (index == start && indices[0] >= end) {
       /* All gone out of hole to be punched, we're done */
       pagevec_remove_exceptionals(&pvec);
       pagevec_release(&pvec);
       break;
     }
     for (i = 0; i < pagevec_count(&pvec); i++) {
       struct page *page = pvec.pages[i];
       /* We rely upon deletion not changing page->index */
       index = indices[i];
       if (index >= end) {
         /* Restart punch to make sure all gone */
         index = start - 1;
         break;
       }
       if (radix_tree_exceptional_entry(page)) continue;
       lock_page(page);
       WARN_ON(page_to_index(page) != index);
       wait_on_page_writeback(page);
       truncate_inode_page(mapping, page);
       unlock_page(page);
     }
     truncate_exceptional_pvec_entries(mapping, &pvec, indices, end);
     pagevec_release(&pvec);
     index++;
   }
 out:
   cleancache_invalidate_inode(mapping);
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);