imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,59 +1,59 @@
 static void __munlock_pagevec(struct pagevec *pvec, struct zone *zone) {
   int i;
   int nr = pagevec_count(pvec);
   int delta_munlocked = -nr;
   struct pagevec pvec_putback;
   int pgrescued = 0;
-  pagevec_init(&pvec_putback, 0);
+  pagevec_init(&pvec_putback);
   /* Phase 1: page isolation */
   spin_lock_irq(zone_lru_lock(zone));
   for (i = 0; i < nr; i++) {
     struct page *page = pvec->pages[i];
     if (TestClearPageMlocked(page)) {
       /*
        * We already have pin from follow_page_mask()
        * so we can spare the get_page() here.
        */
       if (__munlock_isolate_lru_page(page, false))
         continue;
       else
         __munlock_isolation_failed(page);
     } else {
       delta_munlocked++;
     }
     /*
      * We won't be munlocking this page in the next phase
      * but we still need to release the follow_page_mask()
      * pin. We cannot do it under lru_lock however. If it's
      * the last pin, __page_cache_release() would deadlock.
      */
     pagevec_add(&pvec_putback, pvec->pages[i]);
     pvec->pages[i] = NULL;
   }
   __mod_zone_page_state(zone, NR_MLOCK, delta_munlocked);
   spin_unlock_irq(zone_lru_lock(zone));
   /* Now we can release pins of pages that we are not munlocking */
   pagevec_release(&pvec_putback);
   /* Phase 2: page munlock */
   for (i = 0; i < nr; i++) {
     struct page *page = pvec->pages[i];
     if (page) {
       lock_page(page);
       if (!__putback_lru_fast_prepare(page, &pvec_putback, &pgrescued)) {
         /*
          * Slow path. We don't want to lose the last
          * pin before unlock_page()
          */
         get_page(page); /* for putback_lru_page() */
         __munlock_isolated_page(page);
         unlock_page(page);
         put_page(page); /* from follow_page_mask() */
       }
     }
   }
   /*
    * Phase 3: page putback for pages that qualified for the fast path
    * This will also call put_page() to return pin from follow_page_mask()
    */
   if (pagevec_count(&pvec_putback)) __putback_lru_fast(&pvec_putback, pgrescued);
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,57 +1,57 @@
 void munlock_vma_pages_range(struct vm_area_struct *vma, unsigned long start, unsigned long end) {
   vma->vm_flags &= VM_LOCKED_CLEAR_MASK;
   while (start < end) {
     struct page *page;
     unsigned int page_mask = 0;
     unsigned long page_increm;
     struct pagevec pvec;
     struct zone *zone;
-    pagevec_init(&pvec, 0);
+    pagevec_init(&pvec);
     /*
      * Although FOLL_DUMP is intended for get_dump_page(),
      * it just so happens that its special treatment of the
      * ZERO_PAGE (returning an error instead of doing get_page)
      * suits munlock very well (and if somehow an abnormal page
      * has sneaked into the range, we won't oops here: great).
      */
     page = follow_page(vma, start, FOLL_GET | FOLL_DUMP);
     if (page && !IS_ERR(page)) {
       if (PageTransTail(page)) {
         VM_BUG_ON_PAGE(PageMlocked(page), page);
         put_page(page); /* follow_page_mask() */
       } else if (PageTransHuge(page)) {
         lock_page(page);
         /*
          * Any THP page found by follow_page_mask() may
          * have gotten split before reaching
          * munlock_vma_page(), so we need to compute
          * the page_mask here instead.
          */
         page_mask = munlock_vma_page(page);
         unlock_page(page);
         put_page(page); /* follow_page_mask() */
       } else {
         /*
          * Non-huge pages are handled in batches via
          * pagevec. The pin from follow_page_mask()
          * prevents them from collapsing by THP.
          */
         pagevec_add(&pvec, page);
         zone = page_zone(page);
         /*
          * Try to fill the rest of pagevec using fast
          * pte walk. This will also update start to
          * the next page to process. Then munlock the
          * pagevec.
          */
         start = __munlock_pagevec_fill(&pvec, vma, zone, start, end);
         __munlock_pagevec(&pvec, zone);
         goto next;
       }
     }
     page_increm = 1 + page_mask;
     start += page_increm * PAGE_SIZE;
   next:
     cond_resched();
   }
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,84 +1,84 @@
 int fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode, struct writeback_control *wbc, bool atomic) {
   pgoff_t index;
   pgoff_t last_idx = ULONG_MAX;
   struct pagevec pvec;
   int ret = 0;
   struct page *last_page = NULL;
   bool marked = false;
   nid_t ino = inode->i_ino;
   int nr_pages;
   if (atomic) {
     last_page = last_fsync_dnode(sbi, ino);
     if (IS_ERR_OR_NULL(last_page)) return PTR_ERR_OR_ZERO(last_page);
   }
 retry:
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   index = 0;
   while ((nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index, PAGECACHE_TAG_DIRTY))) {
     int i;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       bool submitted = false;
       if (unlikely(f2fs_cp_error(sbi))) {
         f2fs_put_page(last_page, 0);
         pagevec_release(&pvec);
         ret = -EIO;
         goto out;
       }
       if (!IS_DNODE(page) || !is_cold_node(page)) continue;
       if (ino_of_node(page) != ino) continue;
       lock_page(page);
       if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
       continue_unlock:
         unlock_page(page);
         continue;
       }
       if (ino_of_node(page) != ino) goto continue_unlock;
       if (!PageDirty(page) && page != last_page) {
         /* someone wrote it for us */
         goto continue_unlock;
       }
       f2fs_wait_on_page_writeback(page, NODE, true);
       BUG_ON(PageWriteback(page));
       set_fsync_mark(page, 0);
       set_dentry_mark(page, 0);
       if (!atomic || page == last_page) {
         set_fsync_mark(page, 1);
         if (IS_INODE(page)) {
           if (is_inode_flag_set(inode, FI_DIRTY_INODE)) update_inode(inode, page);
           set_dentry_mark(page, need_dentry_mark(sbi, ino));
         }
         /*  may be written by other thread */
         if (!PageDirty(page)) set_page_dirty(page);
       }
       if (!clear_page_dirty_for_io(page)) goto continue_unlock;
       ret = __write_node_page(page, atomic && page == last_page, &submitted, wbc, true, FS_NODE_IO);
       if (ret) {
         unlock_page(page);
         f2fs_put_page(last_page, 0);
         break;
       } else if (submitted) {
         last_idx = page->index;
       }
       if (page == last_page) {
         f2fs_put_page(page, 0);
         marked = true;
         break;
       }
     }
     pagevec_release(&pvec);
     cond_resched();
     if (ret || marked) break;
   }
   if (!ret && atomic && !marked) {
     f2fs_msg(sbi->sb, KERN_DEBUG, "Retry to write fsync mark: ino=%u, idx=%lx", ino, last_page->index);
     lock_page(last_page);
     f2fs_wait_on_page_writeback(last_page, NODE, true);
     set_page_dirty(last_page);
     unlock_page(last_page);
     goto retry;
   }
 out:
   if (last_idx != ULONG_MAX) f2fs_submit_merged_write_cond(sbi, NULL, ino, last_idx, NODE);
   return ret ? -EIO : 0;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,39 +1,39 @@
 static struct page *last_fsync_dnode(struct f2fs_sb_info *sbi, nid_t ino) {
   pgoff_t index;
   struct pagevec pvec;
   struct page *last_page = NULL;
   int nr_pages;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   index = 0;
   while ((nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index, PAGECACHE_TAG_DIRTY))) {
     int i;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       if (unlikely(f2fs_cp_error(sbi))) {
         f2fs_put_page(last_page, 0);
         pagevec_release(&pvec);
         return ERR_PTR(-EIO);
       }
       if (!IS_DNODE(page) || !is_cold_node(page)) continue;
       if (ino_of_node(page) != ino) continue;
       lock_page(page);
       if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
       continue_unlock:
         unlock_page(page);
         continue;
       }
       if (ino_of_node(page) != ino) goto continue_unlock;
       if (!PageDirty(page)) {
         /* someone wrote it for us */
         goto continue_unlock;
       }
       if (last_page) f2fs_put_page(last_page, 0);
       get_page(page);
       last_page = page;
       unlock_page(page);
     }
     pagevec_release(&pvec);
     cond_resched();
   }
   return last_page;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,74 +1,74 @@
 int sync_node_pages(struct f2fs_sb_info *sbi, struct writeback_control *wbc, bool do_balance, enum iostat_type io_type) {
   pgoff_t index;
   struct pagevec pvec;
   int step = 0;
   int nwritten = 0;
   int ret = 0;
   int nr_pages;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
 next_step:
   index = 0;
   while ((nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index, PAGECACHE_TAG_DIRTY))) {
     int i;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       bool submitted = false;
       if (unlikely(f2fs_cp_error(sbi))) {
         pagevec_release(&pvec);
         ret = -EIO;
         goto out;
       }
       /*
        * flushing sequence with step:
        * 0. indirect nodes
        * 1. dentry dnodes
        * 2. file dnodes
        */
       if (step == 0 && IS_DNODE(page)) continue;
       if (step == 1 && (!IS_DNODE(page) || is_cold_node(page))) continue;
       if (step == 2 && (!IS_DNODE(page) || !is_cold_node(page))) continue;
     lock_node:
       if (!trylock_page(page)) continue;
       if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
       continue_unlock:
         unlock_page(page);
         continue;
       }
       if (!PageDirty(page)) {
         /* someone wrote it for us */
         goto continue_unlock;
       }
       /* flush inline_data */
       if (is_inline_node(page)) {
         clear_inline_node(page);
         unlock_page(page);
         flush_inline_data(sbi, ino_of_node(page));
         goto lock_node;
       }
       f2fs_wait_on_page_writeback(page, NODE, true);
       BUG_ON(PageWriteback(page));
       if (!clear_page_dirty_for_io(page)) goto continue_unlock;
       set_fsync_mark(page, 0);
       set_dentry_mark(page, 0);
       ret = __write_node_page(page, false, &submitted, wbc, do_balance, io_type);
       if (ret)
         unlock_page(page);
       else if (submitted)
         nwritten++;
       if (--wbc->nr_to_write == 0) break;
     }
     pagevec_release(&pvec);
     cond_resched();
     if (wbc->nr_to_write == 0) {
       step = 2;
       break;
     }
   }
   if (step < 2) {
     step++;
     goto next_step;
   }
 out:
   if (nwritten) f2fs_submit_merged_write(sbi, NODE);
   return ret;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,22 +1,22 @@
 int wait_on_node_pages_writeback(struct f2fs_sb_info *sbi, nid_t ino) {
   pgoff_t index = 0;
   struct pagevec pvec;
   int ret2, ret = 0;
   int nr_pages;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while ((nr_pages = pagevec_lookup_tag(&pvec, NODE_MAPPING(sbi), &index, PAGECACHE_TAG_WRITEBACK))) {
     int i;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       if (ino && ino_of_node(page) == ino) {
         f2fs_wait_on_page_writeback(page, NODE, true);
         if (TestClearPageError(page)) ret = -EIO;
       }
     }
     pagevec_release(&pvec);
     cond_resched();
   }
   ret2 = filemap_check_errors(NODE_MAPPING(sbi));
   if (!ret) ret = ret2;
   return ret;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,16 +1,16 @@
 void nilfs_clear_dirty_pages(struct address_space *mapping, bool silent) {
   struct pagevec pvec;
   unsigned int i;
   pgoff_t index = 0;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while (pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY)) {
     for (i = 0; i < pagevec_count(&pvec); i++) {
       struct page *page = pvec.pages[i];
       lock_page(page);
       nilfs_clear_dirty_page(page, silent);
       unlock_page(page);
     }
     pagevec_release(&pvec);
     cond_resched();
   }
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,47 +1,47 @@
 void nilfs_copy_back_pages(struct address_space *dmap, struct address_space *smap) {
   struct pagevec pvec;
   unsigned int i, n;
   pgoff_t index = 0;
   int err;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
 repeat:
   n = pagevec_lookup(&pvec, smap, &index);
   if (!n) return;
   for (i = 0; i < pagevec_count(&pvec); i++) {
     struct page *page = pvec.pages[i], *dpage;
     pgoff_t offset = page->index;
     lock_page(page);
     dpage = find_lock_page(dmap, offset);
     if (dpage) {
       /* override existing page on the destination cache */
       WARN_ON(PageDirty(dpage));
       nilfs_copy_page(dpage, page, 0);
       unlock_page(dpage);
       put_page(dpage);
     } else {
       struct page *page2;
       /* move the page to the destination cache */
       spin_lock_irq(&smap->tree_lock);
       page2 = radix_tree_delete(&smap->page_tree, offset);
       WARN_ON(page2 != page);
       smap->nrpages--;
       spin_unlock_irq(&smap->tree_lock);
       spin_lock_irq(&dmap->tree_lock);
       err = radix_tree_insert(&dmap->page_tree, offset, page);
       if (unlikely(err < 0)) {
         WARN_ON(err == -EEXIST);
         page->mapping = NULL;
         put_page(page); /* for cache */
       } else {
         page->mapping = dmap;
         dmap->nrpages++;
         if (PageDirty(page)) radix_tree_tag_set(&dmap->page_tree, offset, PAGECACHE_TAG_DIRTY);
       }
       spin_unlock_irq(&dmap->tree_lock);
     }
     unlock_page(page);
   }
   pagevec_release(&pvec);
   cond_resched();
   goto repeat;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,31 +1,31 @@
 int nilfs_copy_dirty_pages(struct address_space *dmap, struct address_space *smap) {
   struct pagevec pvec;
   unsigned int i;
   pgoff_t index = 0;
   int err = 0;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
 repeat:
   if (!pagevec_lookup_tag(&pvec, smap, &index, PAGECACHE_TAG_DIRTY)) return 0;
   for (i = 0; i < pagevec_count(&pvec); i++) {
     struct page *page = pvec.pages[i], *dpage;
     lock_page(page);
     if (unlikely(!PageDirty(page))) NILFS_PAGE_BUG(page, "inconsistent dirty state");
     dpage = grab_cache_page(dmap, page->index);
     if (unlikely(!dpage)) {
       /* No empty page is added to the page cache */
       err = -ENOMEM;
       unlock_page(page);
       break;
     }
     if (unlikely(!page_has_buffers(page))) NILFS_PAGE_BUG(page, "found empty page in dat page cache");
     nilfs_copy_page(dpage, page, 1);
     __set_page_dirty_nobuffers(dpage);
     unlock_page(dpage);
     put_page(dpage);
     unlock_page(page);
   }
   pagevec_release(&pvec);
   cond_resched();
   if (likely(!err)) goto repeat;
   return err;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,49 +1,49 @@
 unsigned long nilfs_find_uncommitted_extent(struct inode *inode, sector_t start_blk, sector_t *blkoff) {
   unsigned int i;
   pgoff_t index;
   unsigned int nblocks_in_page;
   unsigned long length = 0;
   sector_t b;
   struct pagevec pvec;
   struct page *page;
   if (inode->i_mapping->nrpages == 0) return 0;
   index = start_blk >> (PAGE_SHIFT - inode->i_blkbits);
   nblocks_in_page = 1U << (PAGE_SHIFT - inode->i_blkbits);
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
 repeat:
   pvec.nr = find_get_pages_contig(inode->i_mapping, index, PAGEVEC_SIZE, pvec.pages);
   if (pvec.nr == 0) return length;
   if (length > 0 && pvec.pages[0]->index > index) goto out;
   b = pvec.pages[0]->index << (PAGE_SHIFT - inode->i_blkbits);
   i = 0;
   do {
     page = pvec.pages[i];
     lock_page(page);
     if (page_has_buffers(page)) {
       struct buffer_head *bh, *head;
       bh = head = page_buffers(page);
       do {
         if (b < start_blk) continue;
         if (buffer_delay(bh)) {
           if (length == 0) *blkoff = b;
           length++;
         } else if (length > 0) {
           goto out_locked;
         }
       } while (++b, bh = bh->b_this_page, bh != head);
     } else {
       if (length > 0) goto out_locked;
       b += nblocks_in_page;
     }
     unlock_page(page);
   } while (++i < pagevec_count(&pvec));
   index = page->index + 1;
   pagevec_release(&pvec);
   cond_resched();
   goto repeat;
 out_locked:
   unlock_page(page);
 out:
   pagevec_release(&pvec);
   return length;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,24 +1,24 @@
 int cachefiles_allocate_pages(struct fscache_retrieval *op, struct list_head *pages, unsigned *nr_pages, gfp_t gfp) {
   struct cachefiles_object *object;
   struct cachefiles_cache *cache;
   struct pagevec pagevec;
   struct page *page;
   int ret;
   object = container_of(op->op.object, struct cachefiles_object, fscache);
   cache = container_of(object->fscache.cache, struct cachefiles_cache, cache);
   _enter("%p,,,%d,", object, *nr_pages);
   ret = cachefiles_has_space(cache, 0, *nr_pages);
   if (ret == 0) {
-    pagevec_init(&pagevec, 0);
+    pagevec_init(&pagevec);
     list_for_each_entry(page, pages, lru) {
       if (pagevec_add(&pagevec, page) == 0) fscache_mark_pages_cached(op, &pagevec);
     }
     if (pagevec_count(&pagevec) > 0) fscache_mark_pages_cached(op, &pagevec);
     ret = -ENODATA;
   } else {
     ret = -ENOBUFS;
   }
   fscache_retrieval_complete(op, *nr_pages);
   _leave(" = %d", ret);
   return ret;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,68 +1,68 @@
 int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op, struct list_head *pages, unsigned *nr_pages, gfp_t gfp) {
   struct cachefiles_object *object;
   struct cachefiles_cache *cache;
   struct list_head backpages;
   struct pagevec pagevec;
   struct inode *inode;
   struct page *page, *_n;
   unsigned shift, nrbackpages;
   int ret, ret2, space;
   object = container_of(op->op.object, struct cachefiles_object, fscache);
   cache = container_of(object->fscache.cache, struct cachefiles_cache, cache);
   _enter("{OBJ%x,%d},,%d,,", object->fscache.debug_id, atomic_read(&op->op.usage), *nr_pages);
   if (!object->backer) goto all_enobufs;
   space = 1;
   if (cachefiles_has_space(cache, 0, *nr_pages) < 0) space = 0;
   inode = d_backing_inode(object->backer);
   ASSERT(S_ISREG(inode->i_mode));
   ASSERT(inode->i_mapping->a_ops->bmap);
   ASSERT(inode->i_mapping->a_ops->readpages);
   /* calculate the shift required to use bmap */
   shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;
-  pagevec_init(&pagevec, 0);
+  pagevec_init(&pagevec);
   op->op.flags &= FSCACHE_OP_KEEP_FLAGS;
   op->op.flags |= FSCACHE_OP_ASYNC;
   op->op.processor = cachefiles_read_copier;
   INIT_LIST_HEAD(&backpages);
   nrbackpages = 0;
   ret = space ? -ENODATA : -ENOBUFS;
   list_for_each_entry_safe(page, _n, pages, lru) {
     sector_t block0, block;
     /* we assume the absence or presence of the first block is a
      * good enough indication for the page as a whole
      * - TODO: don't use bmap() for this as it is _not_ actually
      *   good enough for this as it doesn't indicate errors, but
      *   it's all we've got for the moment
      */
     block0 = page->index;
     block0 <<= shift;
     block = inode->i_mapping->a_ops->bmap(inode->i_mapping, block0);
     _debug("%llx -> %llx", (unsigned long long)block0, (unsigned long long)block);
     if (block) {
       /* we have data - add it to the list to give to the
        * backing fs */
       list_move(&page->lru, &backpages);
       (*nr_pages)--;
       nrbackpages++;
     } else if (space && pagevec_add(&pagevec, page) == 0) {
       fscache_mark_pages_cached(op, &pagevec);
       fscache_retrieval_complete(op, 1);
       ret = -ENODATA;
     } else {
       fscache_retrieval_complete(op, 1);
     }
   }
   if (pagevec_count(&pagevec) > 0) fscache_mark_pages_cached(op, &pagevec);
   if (list_empty(pages)) ret = 0;
   /* submit the apparently valid pages to the backing fs to be read from
    * disk */
   if (nrbackpages > 0) {
     ret2 = cachefiles_read_backing_file(object, op, &backpages);
     if (ret2 == -ENOMEM || ret2 == -EINTR) ret = ret2;
   }
   _leave(" = %d [nr=%u%s]", ret, *nr_pages, list_empty(pages) ? " empty" : "");
   return ret;
 all_enobufs:
   fscache_retrieval_complete(op, *nr_pages);
   return -ENOBUFS;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,41 +1,41 @@
 static size_t nilfs_lookup_dirty_data_buffers(struct inode *inode, struct list_head *listp, size_t nlimit, loff_t start, loff_t end) {
   struct address_space *mapping = inode->i_mapping;
   struct pagevec pvec;
   pgoff_t index = 0, last = ULONG_MAX;
   size_t ndirties = 0;
   int i;
   if (unlikely(start != 0 || end != LLONG_MAX)) {
     /*
      * A valid range is given for sync-ing data pages. The
      * range is rounded to per-page; extra dirty buffers
      * may be included if blocksize < pagesize.
      */
     index = start >> PAGE_SHIFT;
     last = end >> PAGE_SHIFT;
   }
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
 repeat:
   if (unlikely(index > last) || !pagevec_lookup_range_tag(&pvec, mapping, &index, last, PAGECACHE_TAG_DIRTY)) return ndirties;
   for (i = 0; i < pagevec_count(&pvec); i++) {
     struct buffer_head *bh, *head;
     struct page *page = pvec.pages[i];
     lock_page(page);
     if (!page_has_buffers(page)) create_empty_buffers(page, i_blocksize(inode), 0);
     unlock_page(page);
     bh = head = page_buffers(page);
     do {
       if (!buffer_dirty(bh) || buffer_async_write(bh)) continue;
       get_bh(bh);
       list_add_tail(&bh->b_assoc_buffers, listp);
       ndirties++;
       if (unlikely(ndirties >= nlimit)) {
         pagevec_release(&pvec);
         cond_resched();
         return ndirties;
       }
     } while (bh = bh->b_this_page, bh != head);
   }
   pagevec_release(&pvec);
   cond_resched();
   goto repeat;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,23 +1,23 @@
 static void nilfs_lookup_dirty_node_buffers(struct inode *inode, struct list_head *listp) {
   struct nilfs_inode_info *ii = NILFS_I(inode);
   struct address_space *mapping = &ii->i_btnode_cache;
   struct pagevec pvec;
   struct buffer_head *bh, *head;
   unsigned int i;
   pgoff_t index = 0;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while (pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY)) {
     for (i = 0; i < pagevec_count(&pvec); i++) {
       bh = head = page_buffers(pvec.pages[i]);
       do {
         if (buffer_dirty(bh) && !buffer_async_write(bh)) {
           get_bh(bh);
           list_add_tail(&bh->b_assoc_buffers, listp);
         }
         bh = bh->b_this_page;
       } while (bh != head);
     }
     pagevec_release(&pvec);
     cond_resched();
   }
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);