--- initial
+++ final
@@ -1,116 +1,116 @@
 int write_cache_pages(struct address_space *mapping, struct writeback_control *wbc, writepage_t writepage, void *data) {
   int ret = 0;
   int done = 0;
   struct pagevec pvec;
   int nr_pages;
   pgoff_t uninitialized_var(writeback_index);
   pgoff_t index;
   pgoff_t end; /* Inclusive */
   pgoff_t done_index;
   int cycled;
   int range_whole = 0;
   int tag;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   if (wbc->range_cyclic) {
     writeback_index = mapping->writeback_index; /* prev offset */
     index = writeback_index;
     if (index == 0)
       cycled = 1;
     else
       cycled = 0;
     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;
     cycled = 1; /* ignore range_cyclic tests */
   }
   if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
     tag = PAGECACHE_TAG_TOWRITE;
   else
     tag = PAGECACHE_TAG_DIRTY;
 retry:
   if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages) tag_pages_for_writeback(mapping, index, end);
   done_index = index;
   while (!done && (index <= end)) {
     int i;
     nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end, tag);
     if (nr_pages == 0) break;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       done_index = page->index;
       lock_page(page);
       /*
        * Page truncated or invalidated. We can freely skip it
        * then, even for data integrity operations: the page
        * has disappeared concurrently, so there could be no
        * real expectation of this data interity operation
        * even if there is now a new, dirty page at the same
        * pagecache address.
        */
       if (unlikely(page->mapping != mapping)) {
       continue_unlock:
         unlock_page(page);
         continue;
       }
       if (!PageDirty(page)) {
         /* someone wrote it for us */
         goto continue_unlock;
       }
       if (PageWriteback(page)) {
         if (wbc->sync_mode != WB_SYNC_NONE)
           wait_on_page_writeback(page);
         else
           goto continue_unlock;
       }
       BUG_ON(PageWriteback(page));
       if (!clear_page_dirty_for_io(page)) goto continue_unlock;
       trace_wbc_writepage(wbc, inode_to_bdi(mapping->host));
       ret = (*writepage)(page, wbc, data);
       if (unlikely(ret)) {
         if (ret == AOP_WRITEPAGE_ACTIVATE) {
           unlock_page(page);
           ret = 0;
         } else {
           /*
            * 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;
         }
       }
       /*
        * We stop writing back only if we are not doing
        * integrity sync. In case of integrity sync we have to
        * keep going until we have written all the pages
        * we tagged for writeback prior to entering this loop.
        */
       if (--wbc->nr_to_write <= 0 && wbc->sync_mode == WB_SYNC_NONE) {
         done = 1;
         break;
       }
     }
     pagevec_release(&pvec);
     cond_resched();
   }
   if (!cycled && !done) {
     /*
      * range_cyclic:
      * We hit the last page and there is more work to be done: wrap
      * back to the start of the file
      */
     cycled = 1;
     index = 0;
     end = writeback_index - 1;
     goto retry;
   }
   if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) mapping->writeback_index = done_index;
   return ret;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);