--- initial
+++ final
@@ -1,111 +1,111 @@
 static int extent_write_cache_pages(struct address_space *mapping, struct writeback_control *wbc, writepage_t writepage, void *data, void (*flush_fn)(void *)) {
   struct inode *inode = mapping->host;
   int ret = 0;
   int done = 0;
   int nr_to_write_done = 0;
   struct pagevec pvec;
   int nr_pages;
   pgoff_t index;
   pgoff_t end; /* Inclusive */
   pgoff_t done_index;
   int range_whole = 0;
   int scanned = 0;
   int tag;
   /*
    * We have to hold onto the inode so that ordered extents can do their
    * work when the IO finishes.  The alternative to this is failing to add
    * an ordered extent if the igrab() fails there and that is a huge pain
    * to deal with, so instead just hold onto the inode throughout the
    * writepages operation.  If it fails here we are freeing up the inode
    * anyway and we'd rather not waste our time writing out stuff that is
    * going to be truncated anyway.
    */
   if (!igrab(inode)) return 0;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   if (wbc->range_cyclic) {
     index = mapping->writeback_index; /* Start from prev offset */
     end = -1;
   } else {
     index = wbc->range_start >> PAGE_SHIFT;
     end = wbc->range_end >> PAGE_SHIFT;
     if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) range_whole = 1;
     scanned = 1;
   }
   if (wbc->sync_mode == WB_SYNC_ALL)
     tag = PAGECACHE_TAG_TOWRITE;
   else
     tag = PAGECACHE_TAG_DIRTY;
 retry:
   if (wbc->sync_mode == WB_SYNC_ALL) tag_pages_for_writeback(mapping, index, end);
   done_index = index;
   while (!done && !nr_to_write_done && (index <= end) && (nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end, tag))) {
     unsigned i;
     scanned = 1;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       done_index = page->index;
       /*
        * At this point we hold neither mapping->tree_lock nor
        * lock on the page itself: the page may be truncated or
        * invalidated (changing page->mapping to NULL), or even
        * swizzled back from swapper_space to tmpfs file
        * mapping
        */
       if (!trylock_page(page)) {
         flush_fn(data);
         lock_page(page);
       }
       if (unlikely(page->mapping != mapping)) {
         unlock_page(page);
         continue;
       }
       if (wbc->sync_mode != WB_SYNC_NONE) {
         if (PageWriteback(page)) flush_fn(data);
         wait_on_page_writeback(page);
       }
       if (PageWriteback(page) || !clear_page_dirty_for_io(page)) {
         unlock_page(page);
         continue;
       }
       ret = (*writepage)(page, wbc, data);
       if (unlikely(ret == AOP_WRITEPAGE_ACTIVATE)) {
         unlock_page(page);
         ret = 0;
       }
       if (ret < 0) {
         /*
          * done_index is set past this page,
          * so media errors will not choke
          * background writeout for the entire
          * file. This has consequences for
          * range_cyclic semantics (ie. it may
          * not be suitable for data integrity
          * writeout).
          */
         done_index = page->index + 1;
         done = 1;
         break;
       }
       /*
        * the filesystem may choose to bump up nr_to_write.
        * We have to make sure to honor the new nr_to_write
        * at any time
        */
       nr_to_write_done = wbc->nr_to_write <= 0;
     }
     pagevec_release(&pvec);
     cond_resched();
   }
   if (!scanned && !done) {
     /*
      * We hit the last page and there is more work to be done: wrap
      * back to the start of the file
      */
     scanned = 1;
     index = 0;
     goto retry;
   }
   if (wbc->range_cyclic || (wbc->nr_to_write > 0 && range_whole)) mapping->writeback_index = done_index;
   btrfs_add_delayed_iput(inode);
   return ret;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);