imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,57 +1,57 @@
 static int gfs2_write_cache_jdata(struct address_space *mapping, struct writeback_control *wbc) {
   int ret = 0;
   int done = 0;
   struct pagevec pvec;
   int nr_pages;
   pgoff_t uninitialized_var(writeback_index);
   pgoff_t index;
   pgoff_t end;
   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)) {
     nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end, tag);
     if (nr_pages == 0) break;
     ret = gfs2_write_jdata_pagevec(mapping, wbc, &pvec, nr_pages, end, &done_index);
     if (ret) done = 1;
     if (ret > 0) ret = 0;
     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);
--- initial
+++ final
@@ -1,23 +1,23 @@
 static void nilfs_btree_lookup_dirty_buffers(struct nilfs_bmap *btree, struct list_head *listp) {
   struct address_space *btcache = &NILFS_BMAP_I(btree)->i_btnode_cache;
   struct list_head lists[NILFS_BTREE_LEVEL_MAX];
   struct pagevec pvec;
   struct buffer_head *bh, *head;
   pgoff_t index = 0;
   int level, i;
   for (level = NILFS_BTREE_LEVEL_NODE_MIN; level < NILFS_BTREE_LEVEL_MAX; level++)
     INIT_LIST_HEAD(&lists[level]);
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while (pagevec_lookup_tag(&pvec, btcache, &index, PAGECACHE_TAG_DIRTY)) {
     for (i = 0; i < pagevec_count(&pvec); i++) {
       bh = head = page_buffers(pvec.pages[i]);
       do {
         if (buffer_dirty(bh)) nilfs_btree_add_dirty_buffer(btree, lists, bh);
       } while ((bh = bh->b_this_page) != head);
     }
     pagevec_release(&pvec);
     cond_resched();
   }
   for (level = NILFS_BTREE_LEVEL_NODE_MIN; level < NILFS_BTREE_LEVEL_MAX; level++)
     list_splice_tail(&lists[level], listp);
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,44 +1,44 @@
 void clean_bdev_aliases(struct block_device *bdev, sector_t block, sector_t len) {
   struct inode *bd_inode = bdev->bd_inode;
   struct address_space *bd_mapping = bd_inode->i_mapping;
   struct pagevec pvec;
   pgoff_t index = block >> (PAGE_SHIFT - bd_inode->i_blkbits);
   pgoff_t end;
   int i, count;
   struct buffer_head *bh;
   struct buffer_head *head;
   end = (block + len - 1) >> (PAGE_SHIFT - bd_inode->i_blkbits);
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while (pagevec_lookup_range(&pvec, bd_mapping, &index, end)) {
     count = pagevec_count(&pvec);
     for (i = 0; i < count; i++) {
       struct page *page = pvec.pages[i];
       if (!page_has_buffers(page)) continue;
       /*
        * We use page lock instead of bd_mapping->private_lock
        * to pin buffers here since we can afford to sleep and
        * it scales better than a global spinlock lock.
        */
       lock_page(page);
       /* Recheck when the page is locked which pins bhs */
       if (!page_has_buffers(page)) goto unlock_page;
       head = page_buffers(page);
       bh = head;
       do {
         if (!buffer_mapped(bh) || (bh->b_blocknr < block)) goto next;
         if (bh->b_blocknr >= block + len) break;
         clear_buffer_dirty(bh);
         wait_on_buffer(bh);
         clear_buffer_req(bh);
       next:
         bh = bh->b_this_page;
       } while (bh != head);
     unlock_page:
       unlock_page(page);
     }
     pagevec_release(&pvec);
     cond_resched();
     /* End of range already reached? */
     if (index > end || !index) break;
   }
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,47 +1,47 @@
 loff_t page_cache_seek_hole_data(struct inode *inode, loff_t offset, loff_t length, int whence) {
   pgoff_t index = offset >> PAGE_SHIFT;
   pgoff_t end = DIV_ROUND_UP(offset + length, PAGE_SIZE);
   loff_t lastoff = offset;
   struct pagevec pvec;
   if (length <= 0) return -ENOENT;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   do {
     unsigned nr_pages, i;
     nr_pages = pagevec_lookup_range(&pvec, inode->i_mapping, &index, end - 1);
     if (nr_pages == 0) break;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       /*
        * At this point, the page may be truncated or
        * invalidated (changing page->mapping to NULL), or
        * even swizzled back from swapper_space to tmpfs file
        * mapping.  However, page->index will not change
        * because we have a reference on the page.
        *
        * If current page offset is beyond where we've ended,
        * we've found a hole.
        */
       if (whence == SEEK_HOLE && lastoff < page_offset(page)) goto check_range;
       lock_page(page);
       if (likely(page->mapping == inode->i_mapping) && page_has_buffers(page)) {
         lastoff = page_seek_hole_data(page, lastoff, whence);
         if (lastoff >= 0) {
           unlock_page(page);
           goto check_range;
         }
       }
       unlock_page(page);
       lastoff = page_offset(page) + PAGE_SIZE;
     }
     pagevec_release(&pvec);
   } while (index < end);
   /* When no page at lastoff and we are not done, we found a hole. */
   if (whence != SEEK_HOLE) goto not_found;
 check_range:
   if (lastoff < offset + length) goto out;
 not_found:
   lastoff = -ENOENT;
 out:
   pagevec_release(&pvec);
   return lastoff;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,50 +1,50 @@
 long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, long nr_to_write, enum iostat_type io_type) {
   struct address_space *mapping = META_MAPPING(sbi);
   pgoff_t index = 0, prev = ULONG_MAX;
   struct pagevec pvec;
   long nwritten = 0;
   int nr_pages;
   struct writeback_control wbc = {
       .for_reclaim = 0,
   };
   struct blk_plug plug;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   blk_start_plug(&plug);
   while ((nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY))) {
     int i;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       if (prev == ULONG_MAX) prev = page->index - 1;
       if (nr_to_write != LONG_MAX && page->index != prev + 1) {
         pagevec_release(&pvec);
         goto stop;
       }
       lock_page(page);
       if (unlikely(page->mapping != mapping)) {
       continue_unlock:
         unlock_page(page);
         continue;
       }
       if (!PageDirty(page)) {
         /* someone wrote it for us */
         goto continue_unlock;
       }
       f2fs_wait_on_page_writeback(page, META, true);
       BUG_ON(PageWriteback(page));
       if (!clear_page_dirty_for_io(page)) goto continue_unlock;
       if (__f2fs_write_meta_page(page, &wbc, io_type)) {
         unlock_page(page);
         break;
       }
       nwritten++;
       prev = page->index;
       if (unlikely(nwritten >= nr_to_write)) break;
     }
     pagevec_release(&pvec);
     cond_resched();
   }
 stop:
   if (nwritten) f2fs_submit_merged_write(sbi, type);
   blk_finish_plug(&plug);
   return nwritten;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,38 +1,38 @@
 int dax_writeback_mapping_range(struct address_space *mapping, struct block_device *bdev, struct writeback_control *wbc) {
   struct inode *inode = mapping->host;
   pgoff_t start_index, end_index;
   pgoff_t indices[PAGEVEC_SIZE];
   struct dax_device *dax_dev;
   struct pagevec pvec;
   bool done = false;
   int i, ret = 0;
   if (WARN_ON_ONCE(inode->i_blkbits != PAGE_SHIFT)) return -EIO;
   if (!mapping->nrexceptional || wbc->sync_mode != WB_SYNC_ALL) return 0;
   dax_dev = dax_get_by_host(bdev->bd_disk->disk_name);
   if (!dax_dev) return -EIO;
   start_index = wbc->range_start >> PAGE_SHIFT;
   end_index = wbc->range_end >> PAGE_SHIFT;
   trace_dax_writeback_range(inode, start_index, end_index);
   tag_pages_for_writeback(mapping, start_index, end_index);
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while (!done) {
     pvec.nr = find_get_entries_tag(mapping, start_index, PAGECACHE_TAG_TOWRITE, PAGEVEC_SIZE, pvec.pages, indices);
     if (pvec.nr == 0) break;
     for (i = 0; i < pvec.nr; i++) {
       if (indices[i] > end_index) {
         done = true;
         break;
       }
       ret = dax_writeback_one(bdev, dax_dev, mapping, indices[i], pvec.pages[i]);
       if (ret < 0) {
         mapping_set_error(mapping, ret);
         goto out;
       }
     }
     start_index = indices[pvec.nr - 1] + 1;
   }
 out:
   put_dax(dax_dev);
   trace_dax_writeback_range_done(inode, start_index, end_index);
   return (ret < 0 ? ret : 0);
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,68 +1,68 @@
 static int mpage_map_and_submit_buffers(struct mpage_da_data *mpd) {
   struct pagevec pvec;
   int nr_pages, i;
   struct inode *inode = mpd->inode;
   struct buffer_head *head, *bh;
   int bpp_bits = PAGE_SHIFT - inode->i_blkbits;
   pgoff_t start, end;
   ext4_lblk_t lblk;
   sector_t pblock;
   int err;
   start = mpd->map.m_lblk >> bpp_bits;
   end = (mpd->map.m_lblk + mpd->map.m_len - 1) >> bpp_bits;
   lblk = start << bpp_bits;
   pblock = mpd->map.m_pblk;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while (start <= end) {
     nr_pages = pagevec_lookup_range(&pvec, inode->i_mapping, &start, end);
     if (nr_pages == 0) break;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       bh = head = page_buffers(page);
       do {
         if (lblk < mpd->map.m_lblk) continue;
         if (lblk >= mpd->map.m_lblk + mpd->map.m_len) {
           /*
            * Buffer after end of mapped extent.
            * Find next buffer in the page to map.
            */
           mpd->map.m_len = 0;
           mpd->map.m_flags = 0;
           /*
            * FIXME: If dioread_nolock supports
            * blocksize < pagesize, we need to make
            * sure we add size mapped so far to
            * io_end->size as the following call
            * can submit the page for IO.
            */
           err = mpage_process_page_bufs(mpd, head, bh, lblk);
           pagevec_release(&pvec);
           if (err > 0) err = 0;
           return err;
         }
         if (buffer_delay(bh)) {
           clear_buffer_delay(bh);
           bh->b_blocknr = pblock++;
         }
         clear_buffer_unwritten(bh);
       } while (lblk++, (bh = bh->b_this_page) != head);
       /*
        * FIXME: This is going to break if dioread_nolock
        * supports blocksize < pagesize as we will try to
        * convert potentially unmapped parts of inode.
        */
       mpd->io_submit.io_end->size += PAGE_SIZE;
       /* Page fully mapped - let IO run! */
       err = mpage_submit_page(mpd, page);
       if (err < 0) {
         pagevec_release(&pvec);
         return err;
       }
     }
     pagevec_release(&pvec);
   }
   /* Extent fully mapped and matches with page boundary. We are done. */
   mpd->map.m_len = 0;
   mpd->map.m_flags = 0;
   return 0;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,67 +1,67 @@
 static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd) {
   struct address_space *mapping = mpd->inode->i_mapping;
   struct pagevec pvec;
   unsigned int nr_pages;
   long left = mpd->wbc->nr_to_write;
   pgoff_t index = mpd->first_page;
   pgoff_t end = mpd->last_page;
   int tag;
   int i, err = 0;
   int blkbits = mpd->inode->i_blkbits;
   ext4_lblk_t lblk;
   struct buffer_head *head;
   if (mpd->wbc->sync_mode == WB_SYNC_ALL || mpd->wbc->tagged_writepages)
     tag = PAGECACHE_TAG_TOWRITE;
   else
     tag = PAGECACHE_TAG_DIRTY;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   mpd->map.m_len = 0;
   mpd->next_page = index;
   while (index <= end) {
     nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end, tag);
     if (nr_pages == 0) goto out;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       /*
        * Accumulated enough dirty pages? This doesn't apply
        * to WB_SYNC_ALL mode. For integrity sync we have to
        * keep going because someone may be concurrently
        * dirtying pages, and we might have synced a lot of
        * newly appeared dirty pages, but have not synced all
        * of the old dirty pages.
        */
       if (mpd->wbc->sync_mode == WB_SYNC_NONE && left <= 0) goto out;
       /* If we can't merge this page, we are done. */
       if (mpd->map.m_len > 0 && mpd->next_page != page->index) goto out;
       lock_page(page);
       /*
        * If the page is no longer dirty, or its mapping no
        * longer corresponds to inode we are writing (which
        * means it has been truncated or invalidated), or the
        * page is already under writeback and we are not doing
        * a data integrity writeback, skip the page
        */
       if (!PageDirty(page) || (PageWriteback(page) && (mpd->wbc->sync_mode == WB_SYNC_NONE)) || unlikely(page->mapping != mapping)) {
         unlock_page(page);
         continue;
       }
       wait_on_page_writeback(page);
       BUG_ON(PageWriteback(page));
       if (mpd->map.m_len == 0) mpd->first_page = page->index;
       mpd->next_page = page->index + 1;
       /* Add all dirty buffers to mpd */
       lblk = ((ext4_lblk_t)page->index) << (PAGE_SHIFT - blkbits);
       head = page_buffers(page);
       err = mpage_process_page_bufs(mpd, head, head, lblk);
       if (err <= 0) goto out;
       err = 0;
       left--;
     }
     pagevec_release(&pvec);
     cond_resched();
   }
   return 0;
 out:
   pagevec_release(&pvec);
   return err;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,34 +1,34 @@
 static void mpage_release_unused_pages(struct mpage_da_data *mpd, bool invalidate) {
   int nr_pages, i;
   pgoff_t index, end;
   struct pagevec pvec;
   struct inode *inode = mpd->inode;
   struct address_space *mapping = inode->i_mapping;
   /* This is necessary when next_page == 0. */
   if (mpd->first_page >= mpd->next_page) return;
   index = mpd->first_page;
   end = mpd->next_page - 1;
   if (invalidate) {
     ext4_lblk_t start, last;
     start = index << (PAGE_SHIFT - inode->i_blkbits);
     last = end << (PAGE_SHIFT - inode->i_blkbits);
     ext4_es_remove_extent(inode, start, last - start + 1);
   }
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while (index <= end) {
     nr_pages = pagevec_lookup_range(&pvec, mapping, &index, end);
     if (nr_pages == 0) break;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       BUG_ON(!PageLocked(page));
       BUG_ON(PageWriteback(page));
       if (invalidate) {
         if (page_mapped(page)) clear_page_dirty_for_io(page);
         block_invalidatepage(page, 0, PAGE_SIZE);
         ClearPageUptodate(page);
       }
       unlock_page(page);
     }
     pagevec_release(&pvec);
   }
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,97 +1,97 @@
 int btree_write_cache_pages(struct address_space *mapping, struct writeback_control *wbc) {
   struct extent_io_tree *tree = &BTRFS_I(mapping->host)->io_tree;
   struct btrfs_fs_info *fs_info = BTRFS_I(mapping->host)->root->fs_info;
   struct extent_buffer *eb, *prev_eb = NULL;
   struct extent_page_data epd = {
       .bio = NULL,
       .tree = tree,
       .extent_locked = 0,
       .sync_io = wbc->sync_mode == WB_SYNC_ALL,
   };
   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 */
   int scanned = 0;
   int tag;
-  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;
     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);
   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];
       if (!PagePrivate(page)) continue;
       spin_lock(&mapping->private_lock);
       if (!PagePrivate(page)) {
         spin_unlock(&mapping->private_lock);
         continue;
       }
       eb = (struct extent_buffer *)page->private;
       /*
        * Shouldn't happen and normally this would be a BUG_ON
        * but no sense in crashing the users box for something
        * we can survive anyway.
        */
       if (WARN_ON(!eb)) {
         spin_unlock(&mapping->private_lock);
         continue;
       }
       if (eb == prev_eb) {
         spin_unlock(&mapping->private_lock);
         continue;
       }
       ret = atomic_inc_not_zero(&eb->refs);
       spin_unlock(&mapping->private_lock);
       if (!ret) continue;
       prev_eb = eb;
       ret = lock_extent_buffer_for_io(eb, fs_info, &epd);
       if (!ret) {
         free_extent_buffer(eb);
         continue;
       }
       ret = write_one_eb(eb, fs_info, wbc, &epd);
       if (ret) {
         done = 1;
         free_extent_buffer(eb);
         break;
       }
       free_extent_buffer(eb);
       /*
        * 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;
   }
   flush_write_bio(&epd);
   return ret;
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,20 +1,20 @@
 static void __filemap_fdatawait_range(struct address_space *mapping, loff_t start_byte, loff_t end_byte) {
   pgoff_t index = start_byte >> PAGE_SHIFT;
   pgoff_t end = end_byte >> PAGE_SHIFT;
   struct pagevec pvec;
   int nr_pages;
   if (end_byte < start_byte) return;
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   while (index <= end) {
     unsigned i;
     nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end, PAGECACHE_TAG_WRITEBACK);
     if (!nr_pages) break;
     for (i = 0; i < nr_pages; i++) {
       struct page *page = pvec.pages[i];
       wait_on_page_writeback(page);
       ClearPageError(page);
     }
     pagevec_release(&pvec);
     cond_resched();
   }
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,26 +1,26 @@
 void __fscache_uncache_all_inode_pages(struct fscache_cookie *cookie, struct inode *inode) {
   struct address_space *mapping = inode->i_mapping;
   struct pagevec pvec;
   pgoff_t next;
   int i;
   _enter("%p,%p", cookie, inode);
   if (!mapping || mapping->nrpages == 0) {
     _leave(" [no pages]");
     return;
   }
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   next = 0;
   do {
     if (!pagevec_lookup(&pvec, mapping, &next)) break;
     for (i = 0; i < pagevec_count(&pvec); i++) {
       struct page *page = pvec.pages[i];
       if (PageFsCache(page)) {
         __fscache_wait_on_page_write(cookie, page);
         __fscache_uncache_page(cookie, page);
       }
     }
     pagevec_release(&pvec);
     cond_resched();
   } while (next);
   _leave("");
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,10 +1,10 @@
 static void i915_address_space_init(struct i915_address_space *vm, struct drm_i915_private *dev_priv, const char *name) {
   i915_gem_timeline_init(dev_priv, &vm->timeline, name);
   drm_mm_init(&vm->mm, 0, vm->total);
   vm->mm.head_node.color = I915_COLOR_UNEVICTABLE;
   INIT_LIST_HEAD(&vm->active_list);
   INIT_LIST_HEAD(&vm->inactive_list);
   INIT_LIST_HEAD(&vm->unbound_list);
   list_add_tail(&vm->global_link, &dev_priv->vm_list);
-  pagevec_init(&vm->free_pages, false);
+  pagevec_init(&vm->free_pages);
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);
--- initial
+++ final
@@ -1,64 +1,64 @@
 static void remove_inode_hugepages(struct inode *inode, loff_t lstart, loff_t lend) {
   struct hstate *h = hstate_inode(inode);
   struct address_space *mapping = &inode->i_data;
   const pgoff_t start = lstart >> huge_page_shift(h);
   const pgoff_t end = lend >> huge_page_shift(h);
   struct vm_area_struct pseudo_vma;
   struct pagevec pvec;
   pgoff_t next, index;
   int i, freed = 0;
   bool truncate_op = (lend == LLONG_MAX);
   memset(&pseudo_vma, 0, sizeof(struct vm_area_struct));
   pseudo_vma.vm_flags = (VM_HUGETLB | VM_MAYSHARE | VM_SHARED);
-  pagevec_init(&pvec, 0);
+  pagevec_init(&pvec);
   next = start;
   while (next < end) {
     /*
      * When no more pages are found, we are done.
      */
     if (!pagevec_lookup_range(&pvec, mapping, &next, end - 1)) break;
     for (i = 0; i < pagevec_count(&pvec); ++i) {
       struct page *page = pvec.pages[i];
       u32 hash;
       index = page->index;
       hash = hugetlb_fault_mutex_hash(h, current->mm, &pseudo_vma, mapping, index, 0);
       mutex_lock(&hugetlb_fault_mutex_table[hash]);
       /*
        * If page is mapped, it was faulted in after being
        * unmapped in caller.  Unmap (again) now after taking
        * the fault mutex.  The mutex will prevent faults
        * until we finish removing the page.
        *
        * This race can only happen in the hole punch case.
        * Getting here in a truncate operation is a bug.
        */
       if (unlikely(page_mapped(page))) {
         BUG_ON(truncate_op);
         i_mmap_lock_write(mapping);
         hugetlb_vmdelete_list(&mapping->i_mmap, index * pages_per_huge_page(h), (index + 1) * pages_per_huge_page(h));
         i_mmap_unlock_write(mapping);
       }
       lock_page(page);
       /*
        * We must free the huge page and remove from page
        * cache (remove_huge_page) BEFORE removing the
        * region/reserve map (hugetlb_unreserve_pages).  In
        * rare out of memory conditions, removal of the
        * region/reserve map could fail. Correspondingly,
        * the subpool and global reserve usage count can need
        * to be adjusted.
        */
       VM_BUG_ON(PagePrivate(page));
       remove_huge_page(page);
       freed++;
       if (!truncate_op) {
         if (unlikely(hugetlb_unreserve_pages(inode, index, index + 1, 1))) hugetlb_fix_reserve_counts(inode);
       }
       unlock_page(page);
       mutex_unlock(&hugetlb_fault_mutex_table[hash]);
     }
     huge_pagevec_release(&pvec);
     cond_resched();
   }
   if (truncate_op) (void)hugetlb_unreserve_pages(inode, start, LONG_MAX, freed);
 }<sep>@@
expression x,e;
@@
-       pagevec_init(x, e);
+       pagevec_init(x);