truncate.c 22.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 * mm/truncate.c - code for taking down pages from address_spaces
 *
 * Copyright (C) 2002, Linus Torvalds
 *
6
 * 10Sep2002	Andrew Morton
L
Linus Torvalds 已提交
7 8 9 10
 *		Initial version.
 */

#include <linux/kernel.h>
A
Alexey Dobriyan 已提交
11
#include <linux/backing-dev.h>
12
#include <linux/gfp.h>
L
Linus Torvalds 已提交
13
#include <linux/mm.h>
N
Nick Piggin 已提交
14
#include <linux/swap.h>
15
#include <linux/export.h>
L
Linus Torvalds 已提交
16
#include <linux/pagemap.h>
17
#include <linux/highmem.h>
L
Linus Torvalds 已提交
18
#include <linux/pagevec.h>
19
#include <linux/task_io_accounting_ops.h>
L
Linus Torvalds 已提交
20
#include <linux/buffer_head.h>	/* grr. try_to_release_page,
21
				   do_invalidatepage */
22
#include <linux/cleancache.h>
23
#include "internal.h"
L
Linus Torvalds 已提交
24

25 26 27
static void clear_exceptional_entry(struct address_space *mapping,
				    pgoff_t index, void *entry)
{
28 29 30
	struct radix_tree_node *node;
	void **slot;

31 32 33 34 35 36 37 38 39 40
	/* Handled by shmem itself */
	if (shmem_mapping(mapping))
		return;

	spin_lock_irq(&mapping->tree_lock);
	/*
	 * Regular page slots are stabilized by the page lock even
	 * without the tree itself locked.  These unlocked entries
	 * need verification under the tree lock.
	 */
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
	if (!__radix_tree_lookup(&mapping->page_tree, index, &node, &slot))
		goto unlock;
	if (*slot != entry)
		goto unlock;
	radix_tree_replace_slot(slot, NULL);
	mapping->nrshadows--;
	if (!node)
		goto unlock;
	workingset_node_shadows_dec(node);
	/*
	 * Don't track node without shadow entries.
	 *
	 * Avoid acquiring the list_lru lock if already untracked.
	 * The list_empty() test is safe as node->private_list is
	 * protected by mapping->tree_lock.
	 */
	if (!workingset_node_shadows(node) &&
	    !list_empty(&node->private_list))
		list_lru_del(&workingset_shadow_nodes, &node->private_list);
	__radix_tree_delete_node(&mapping->page_tree, node);
unlock:
62 63
	spin_unlock_irq(&mapping->tree_lock);
}
L
Linus Torvalds 已提交
64

65
/**
66
 * do_invalidatepage - invalidate part or all of a page
67
 * @page: the page which is affected
68 69
 * @offset: start of the range to invalidate
 * @length: length of the range to invalidate
70 71 72 73 74 75 76 77 78 79
 *
 * do_invalidatepage() is called when all or part of the page has become
 * invalidated by a truncate operation.
 *
 * do_invalidatepage() does not have to release all buffers, but it must
 * ensure that no dirty buffer is left outside @offset and that no I/O
 * is underway against any of the blocks which are outside the truncation
 * point.  Because the caller is about to free (and possibly reuse) those
 * blocks on-disk.
 */
80 81
void do_invalidatepage(struct page *page, unsigned int offset,
		       unsigned int length)
82
{
83 84
	void (*invalidatepage)(struct page *, unsigned int, unsigned int);

85
	invalidatepage = page->mapping->a_ops->invalidatepage;
86
#ifdef CONFIG_BLOCK
87 88
	if (!invalidatepage)
		invalidatepage = block_invalidatepage;
89
#endif
90
	if (invalidatepage)
91
		(*invalidatepage)(page, offset, length);
92 93
}

94 95 96 97 98 99 100 101 102 103 104 105 106 107
/*
 * This cancels just the dirty bit on the kernel page itself, it
 * does NOT actually remove dirty bits on any mmap's that may be
 * around. It also leaves the page tagged dirty, so any sync
 * activity will still find it on the dirty lists, and in particular,
 * clear_page_dirty_for_io() will still look at the dirty bits in
 * the VM.
 *
 * Doing this should *normally* only ever be done when a page
 * is truncated, and is not actually mapped anywhere at all. However,
 * fs/buffer.c does this when it notices that somebody has cleaned
 * out all the buffers on a page without actually doing it through
 * the VM. Can you say "ext3 is horribly ugly"? Tought you could.
 */
108 109
void cancel_dirty_page(struct page *page, unsigned int account_size)
{
110 111 112 113
	if (TestClearPageDirty(page)) {
		struct address_space *mapping = page->mapping;
		if (mapping && mapping_cap_account_dirty(mapping)) {
			dec_zone_page_state(page, NR_FILE_DIRTY);
114 115
			dec_bdi_stat(mapping->backing_dev_info,
					BDI_RECLAIMABLE);
116 117 118
			if (account_size)
				task_io_account_cancelled_write(account_size);
		}
119
	}
120
}
121
EXPORT_SYMBOL(cancel_dirty_page);
122

L
Linus Torvalds 已提交
123 124
/*
 * If truncate cannot remove the fs-private metadata from the page, the page
125
 * becomes orphaned.  It will be left on the LRU and may even be mapped into
126
 * user pagetables if we're racing with filemap_fault().
L
Linus Torvalds 已提交
127 128 129
 *
 * We need to bale out if page->mapping is no longer equal to the original
 * mapping.  This happens a) when the VM reclaimed the page while we waited on
130
 * its lock, b) when a concurrent invalidate_mapping_pages got there first and
L
Linus Torvalds 已提交
131 132
 * c) when tmpfs swizzles a page between a tmpfs inode and swapper_space.
 */
133
static int
L
Linus Torvalds 已提交
134 135 136
truncate_complete_page(struct address_space *mapping, struct page *page)
{
	if (page->mapping != mapping)
137
		return -EIO;
L
Linus Torvalds 已提交
138

139
	if (page_has_private(page))
140
		do_invalidatepage(page, 0, PAGE_CACHE_SIZE);
L
Linus Torvalds 已提交
141

142 143
	cancel_dirty_page(page, PAGE_CACHE_SIZE);

L
Linus Torvalds 已提交
144
	ClearPageMappedToDisk(page);
145
	delete_from_page_cache(page);
146
	return 0;
L
Linus Torvalds 已提交
147 148 149
}

/*
150
 * This is for invalidate_mapping_pages().  That function can be called at
L
Linus Torvalds 已提交
151
 * any time, and is not supposed to throw away dirty pages.  But pages can
N
Nick Piggin 已提交
152 153
 * be marked dirty at any time too, so use remove_mapping which safely
 * discards clean, unused pages.
L
Linus Torvalds 已提交
154 155 156 157 158 159
 *
 * Returns non-zero if the page was successfully invalidated.
 */
static int
invalidate_complete_page(struct address_space *mapping, struct page *page)
{
N
Nick Piggin 已提交
160 161
	int ret;

L
Linus Torvalds 已提交
162 163 164
	if (page->mapping != mapping)
		return 0;

165
	if (page_has_private(page) && !try_to_release_page(page, 0))
L
Linus Torvalds 已提交
166 167
		return 0;

N
Nick Piggin 已提交
168 169 170
	ret = remove_mapping(mapping, page);

	return ret;
L
Linus Torvalds 已提交
171 172
}

173 174 175 176 177 178 179 180 181 182
int truncate_inode_page(struct address_space *mapping, struct page *page)
{
	if (page_mapped(page)) {
		unmap_mapping_range(mapping,
				   (loff_t)page->index << PAGE_CACHE_SHIFT,
				   PAGE_CACHE_SIZE, 0);
	}
	return truncate_complete_page(mapping, page);
}

183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
/*
 * Used to get rid of pages on hardware memory corruption.
 */
int generic_error_remove_page(struct address_space *mapping, struct page *page)
{
	if (!mapping)
		return -EINVAL;
	/*
	 * Only punch for normal data pages for now.
	 * Handling other types like directories would need more auditing.
	 */
	if (!S_ISREG(mapping->host->i_mode))
		return -EIO;
	return truncate_inode_page(mapping, page);
}
EXPORT_SYMBOL(generic_error_remove_page);

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
/*
 * Safely invalidate one page from its pagecache mapping.
 * It only drops clean, unused pages. The page must be locked.
 *
 * Returns 1 if the page is successfully invalidated, otherwise 0.
 */
int invalidate_inode_page(struct page *page)
{
	struct address_space *mapping = page_mapping(page);
	if (!mapping)
		return 0;
	if (PageDirty(page) || PageWriteback(page))
		return 0;
	if (page_mapped(page))
		return 0;
	return invalidate_complete_page(mapping, page);
}

L
Linus Torvalds 已提交
218
/**
219
 * truncate_inode_pages_range - truncate range of pages specified by start & end byte offsets
L
Linus Torvalds 已提交
220 221
 * @mapping: mapping to truncate
 * @lstart: offset from which to truncate
222
 * @lend: offset to which to truncate (inclusive)
L
Linus Torvalds 已提交
223
 *
224
 * Truncate the page cache, removing the pages that are between
225 226
 * specified offsets (and zeroing out partial pages
 * if lstart or lend + 1 is not page aligned).
L
Linus Torvalds 已提交
227 228 229 230 231 232 233 234 235 236
 *
 * Truncate takes two passes - the first pass is nonblocking.  It will not
 * block on page locks and it will not block on writeback.  The second pass
 * will wait.  This is to prevent as much IO as possible in the affected region.
 * The first pass will remove most pages, so the search cost of the second pass
 * is low.
 *
 * We pass down the cache-hot hint to the page freeing code.  Even if the
 * mapping is large, it is probably the case that the final pages are the most
 * recently touched, and freeing happens in ascending file offset order.
237 238 239 240
 *
 * Note that since ->invalidatepage() accepts range to invalidate
 * truncate_inode_pages_range is able to handle cases where lend + 1 is not
 * page aligned properly.
L
Linus Torvalds 已提交
241
 */
242 243
void truncate_inode_pages_range(struct address_space *mapping,
				loff_t lstart, loff_t lend)
L
Linus Torvalds 已提交
244
{
245 246 247 248 249
	pgoff_t		start;		/* inclusive */
	pgoff_t		end;		/* exclusive */
	unsigned int	partial_start;	/* inclusive */
	unsigned int	partial_end;	/* exclusive */
	struct pagevec	pvec;
250
	pgoff_t		indices[PAGEVEC_SIZE];
251 252
	pgoff_t		index;
	int		i;
L
Linus Torvalds 已提交
253

254
	cleancache_invalidate_inode(mapping);
255
	if (mapping->nrpages == 0 && mapping->nrshadows == 0)
L
Linus Torvalds 已提交
256 257
		return;

258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
	/* Offsets within partial pages */
	partial_start = lstart & (PAGE_CACHE_SIZE - 1);
	partial_end = (lend + 1) & (PAGE_CACHE_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_CACHE_SIZE - 1) >> PAGE_CACHE_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_CACHE_SHIFT;
278

L
Linus Torvalds 已提交
279
	pagevec_init(&pvec, 0);
280
	index = start;
281 282 283
	while (index < end && pagevec_lookup_entries(&pvec, mapping, index,
			min(end - index, (pgoff_t)PAGEVEC_SIZE),
			indices)) {
284
		mem_cgroup_uncharge_start();
L
Linus Torvalds 已提交
285 286 287
		for (i = 0; i < pagevec_count(&pvec); i++) {
			struct page *page = pvec.pages[i];

288
			/* We rely upon deletion not changing page->index */
289
			index = indices[i];
290
			if (index >= end)
291 292
				break;

293 294 295 296 297
			if (radix_tree_exceptional_entry(page)) {
				clear_exceptional_entry(mapping, index, page);
				continue;
			}

N
Nick Piggin 已提交
298
			if (!trylock_page(page))
L
Linus Torvalds 已提交
299
				continue;
300
			WARN_ON(page->index != index);
L
Linus Torvalds 已提交
301 302 303 304
			if (PageWriteback(page)) {
				unlock_page(page);
				continue;
			}
305
			truncate_inode_page(mapping, page);
L
Linus Torvalds 已提交
306 307
			unlock_page(page);
		}
308
		pagevec_remove_exceptionals(&pvec);
L
Linus Torvalds 已提交
309
		pagevec_release(&pvec);
310
		mem_cgroup_uncharge_end();
L
Linus Torvalds 已提交
311
		cond_resched();
312
		index++;
L
Linus Torvalds 已提交
313 314
	}

315
	if (partial_start) {
L
Linus Torvalds 已提交
316 317
		struct page *page = find_lock_page(mapping, start - 1);
		if (page) {
318 319 320 321 322 323
			unsigned int top = PAGE_CACHE_SIZE;
			if (start > end) {
				/* Truncation within a single page */
				top = partial_end;
				partial_end = 0;
			}
L
Linus Torvalds 已提交
324
			wait_on_page_writeback(page);
325 326 327 328 329
			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);
L
Linus Torvalds 已提交
330 331 332 333
			unlock_page(page);
			page_cache_release(page);
		}
	}
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
	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);
			page_cache_release(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)
		return;
L
Linus Torvalds 已提交
353

354
	index = start;
L
Linus Torvalds 已提交
355 356
	for ( ; ; ) {
		cond_resched();
357 358 359
		if (!pagevec_lookup_entries(&pvec, mapping, index,
			min(end - index, (pgoff_t)PAGEVEC_SIZE),
			indices)) {
360
			if (index == start)
L
Linus Torvalds 已提交
361
				break;
362
			index = start;
L
Linus Torvalds 已提交
363 364
			continue;
		}
365 366
		if (index == start && indices[0] >= end) {
			pagevec_remove_exceptionals(&pvec);
367 368 369
			pagevec_release(&pvec);
			break;
		}
370
		mem_cgroup_uncharge_start();
L
Linus Torvalds 已提交
371 372 373
		for (i = 0; i < pagevec_count(&pvec); i++) {
			struct page *page = pvec.pages[i];

374
			/* We rely upon deletion not changing page->index */
375
			index = indices[i];
376
			if (index >= end)
377
				break;
378

379 380 381 382 383
			if (radix_tree_exceptional_entry(page)) {
				clear_exceptional_entry(mapping, index, page);
				continue;
			}

L
Linus Torvalds 已提交
384
			lock_page(page);
385
			WARN_ON(page->index != index);
L
Linus Torvalds 已提交
386
			wait_on_page_writeback(page);
387
			truncate_inode_page(mapping, page);
L
Linus Torvalds 已提交
388 389
			unlock_page(page);
		}
390
		pagevec_remove_exceptionals(&pvec);
L
Linus Torvalds 已提交
391
		pagevec_release(&pvec);
392
		mem_cgroup_uncharge_end();
393
		index++;
L
Linus Torvalds 已提交
394
	}
395
	cleancache_invalidate_inode(mapping);
L
Linus Torvalds 已提交
396
}
397
EXPORT_SYMBOL(truncate_inode_pages_range);
L
Linus Torvalds 已提交
398

399 400 401 402 403
/**
 * truncate_inode_pages - truncate *all* the pages from an offset
 * @mapping: mapping to truncate
 * @lstart: offset from which to truncate
 *
404
 * Called under (and serialised by) inode->i_mutex.
405 406 407 408 409
 *
 * Note: When this function returns, there can be a page in the process of
 * deletion (inside __delete_from_page_cache()) in the specified range.  Thus
 * mapping->nrpages can be non-zero when this function returns even after
 * truncation of the whole mapping.
410 411 412 413 414
 */
void truncate_inode_pages(struct address_space *mapping, loff_t lstart)
{
	truncate_inode_pages_range(mapping, lstart, (loff_t)-1);
}
L
Linus Torvalds 已提交
415 416
EXPORT_SYMBOL(truncate_inode_pages);

417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
/**
 * truncate_inode_pages_final - truncate *all* pages before inode dies
 * @mapping: mapping to truncate
 *
 * Called under (and serialized by) inode->i_mutex.
 *
 * Filesystems have to use this in the .evict_inode path to inform the
 * VM that this is the final truncate and the inode is going away.
 */
void truncate_inode_pages_final(struct address_space *mapping)
{
	unsigned long nrshadows;
	unsigned long nrpages;

	/*
	 * Page reclaim can not participate in regular inode lifetime
	 * management (can't call iput()) and thus can race with the
	 * inode teardown.  Tell it when the address space is exiting,
	 * so that it does not install eviction information after the
	 * final truncate has begun.
	 */
	mapping_set_exiting(mapping);

	/*
	 * When reclaim installs eviction entries, it increases
	 * nrshadows first, then decreases nrpages.  Make sure we see
	 * this in the right order or we might miss an entry.
	 */
	nrpages = mapping->nrpages;
	smp_rmb();
	nrshadows = mapping->nrshadows;

	if (nrpages || nrshadows) {
		/*
		 * As truncation uses a lockless tree lookup, cycle
		 * the tree lock to make sure any ongoing tree
		 * modification that does not see AS_EXITING is
		 * completed before starting the final truncate.
		 */
		spin_lock_irq(&mapping->tree_lock);
		spin_unlock_irq(&mapping->tree_lock);

		truncate_inode_pages(mapping, 0);
	}
}
EXPORT_SYMBOL(truncate_inode_pages_final);

464 465 466 467 468 469 470 471 472 473 474 475 476 477
/**
 * invalidate_mapping_pages - Invalidate all the unlocked pages of one inode
 * @mapping: the address_space which holds the pages to invalidate
 * @start: the offset 'from' which to invalidate
 * @end: the offset 'to' which to invalidate (inclusive)
 *
 * This function only removes the unlocked pages, if you want to
 * remove all the pages of one inode, you must call truncate_inode_pages.
 *
 * invalidate_mapping_pages() will not block on IO activity. It will not
 * invalidate pages which are dirty, locked, under writeback or mapped into
 * pagetables.
 */
unsigned long invalidate_mapping_pages(struct address_space *mapping,
M
Minchan Kim 已提交
478
		pgoff_t start, pgoff_t end)
L
Linus Torvalds 已提交
479
{
480
	pgoff_t indices[PAGEVEC_SIZE];
L
Linus Torvalds 已提交
481
	struct pagevec pvec;
482
	pgoff_t index = start;
M
Minchan Kim 已提交
483 484
	unsigned long ret;
	unsigned long count = 0;
L
Linus Torvalds 已提交
485 486 487
	int i;

	pagevec_init(&pvec, 0);
488 489 490
	while (index <= end && pagevec_lookup_entries(&pvec, mapping, index,
			min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1,
			indices)) {
491
		mem_cgroup_uncharge_start();
L
Linus Torvalds 已提交
492 493
		for (i = 0; i < pagevec_count(&pvec); i++) {
			struct page *page = pvec.pages[i];
494

495
			/* We rely upon deletion not changing page->index */
496
			index = indices[i];
497 498
			if (index > end)
				break;
499

500 501 502 503 504
			if (radix_tree_exceptional_entry(page)) {
				clear_exceptional_entry(mapping, index, page);
				continue;
			}

505 506 507
			if (!trylock_page(page))
				continue;
			WARN_ON(page->index != index);
M
Minchan Kim 已提交
508
			ret = invalidate_inode_page(page);
L
Linus Torvalds 已提交
509
			unlock_page(page);
M
Minchan Kim 已提交
510 511 512 513 514 515 516
			/*
			 * Invalidation is a hint that the page is no longer
			 * of interest and try to speed up its reclaim.
			 */
			if (!ret)
				deactivate_page(page);
			count += ret;
L
Linus Torvalds 已提交
517
		}
518
		pagevec_remove_exceptionals(&pvec);
L
Linus Torvalds 已提交
519
		pagevec_release(&pvec);
520
		mem_cgroup_uncharge_end();
521
		cond_resched();
522
		index++;
L
Linus Torvalds 已提交
523
	}
M
Minchan Kim 已提交
524
	return count;
L
Linus Torvalds 已提交
525
}
526
EXPORT_SYMBOL(invalidate_mapping_pages);
L
Linus Torvalds 已提交
527

528 529 530 531
/*
 * This is like invalidate_complete_page(), except it ignores the page's
 * refcount.  We do this because invalidate_inode_pages2() needs stronger
 * invalidation guarantees, and cannot afford to leave pages behind because
532 533
 * shrink_page_list() has a temp ref on them, or because they're transiently
 * sitting in the lru_cache_add() pagevecs.
534 535 536 537 538 539 540
 */
static int
invalidate_complete_page2(struct address_space *mapping, struct page *page)
{
	if (page->mapping != mapping)
		return 0;

541
	if (page_has_private(page) && !try_to_release_page(page, GFP_KERNEL))
542 543
		return 0;

N
Nick Piggin 已提交
544
	spin_lock_irq(&mapping->tree_lock);
545 546 547
	if (PageDirty(page))
		goto failed;

548
	BUG_ON(page_has_private(page));
549
	__delete_from_page_cache(page, NULL);
N
Nick Piggin 已提交
550
	spin_unlock_irq(&mapping->tree_lock);
551
	mem_cgroup_uncharge_cache_page(page);
552 553 554 555

	if (mapping->a_ops->freepage)
		mapping->a_ops->freepage(page);

556 557 558
	page_cache_release(page);	/* pagecache ref */
	return 1;
failed:
N
Nick Piggin 已提交
559
	spin_unlock_irq(&mapping->tree_lock);
560 561 562
	return 0;
}

563 564 565 566 567 568 569 570 571
static int do_launder_page(struct address_space *mapping, struct page *page)
{
	if (!PageDirty(page))
		return 0;
	if (page->mapping != mapping || mapping->a_ops->launder_page == NULL)
		return 0;
	return mapping->a_ops->launder_page(page);
}

L
Linus Torvalds 已提交
572 573
/**
 * invalidate_inode_pages2_range - remove range of pages from an address_space
574
 * @mapping: the address_space
L
Linus Torvalds 已提交
575 576 577 578 579 580
 * @start: the page offset 'from' which to invalidate
 * @end: the page offset 'to' which to invalidate (inclusive)
 *
 * Any pages which are found to be mapped into pagetables are unmapped prior to
 * invalidation.
 *
581
 * Returns -EBUSY if any pages could not be invalidated.
L
Linus Torvalds 已提交
582 583 584 585
 */
int invalidate_inode_pages2_range(struct address_space *mapping,
				  pgoff_t start, pgoff_t end)
{
586
	pgoff_t indices[PAGEVEC_SIZE];
L
Linus Torvalds 已提交
587
	struct pagevec pvec;
588
	pgoff_t index;
L
Linus Torvalds 已提交
589 590
	int i;
	int ret = 0;
591
	int ret2 = 0;
L
Linus Torvalds 已提交
592 593
	int did_range_unmap = 0;

594
	cleancache_invalidate_inode(mapping);
L
Linus Torvalds 已提交
595
	pagevec_init(&pvec, 0);
596
	index = start;
597 598 599
	while (index <= end && pagevec_lookup_entries(&pvec, mapping, index,
			min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1,
			indices)) {
600
		mem_cgroup_uncharge_start();
601
		for (i = 0; i < pagevec_count(&pvec); i++) {
L
Linus Torvalds 已提交
602
			struct page *page = pvec.pages[i];
603 604

			/* We rely upon deletion not changing page->index */
605
			index = indices[i];
606 607
			if (index > end)
				break;
L
Linus Torvalds 已提交
608

609 610 611 612 613
			if (radix_tree_exceptional_entry(page)) {
				clear_exceptional_entry(mapping, index, page);
				continue;
			}

L
Linus Torvalds 已提交
614
			lock_page(page);
615
			WARN_ON(page->index != index);
L
Linus Torvalds 已提交
616 617 618 619 620
			if (page->mapping != mapping) {
				unlock_page(page);
				continue;
			}
			wait_on_page_writeback(page);
621
			if (page_mapped(page)) {
L
Linus Torvalds 已提交
622 623 624 625 626
				if (!did_range_unmap) {
					/*
					 * Zap the rest of the file in one hit.
					 */
					unmap_mapping_range(mapping,
627 628 629
					   (loff_t)index << PAGE_CACHE_SHIFT,
					   (loff_t)(1 + end - index)
							 << PAGE_CACHE_SHIFT,
L
Linus Torvalds 已提交
630 631 632 633 634 635 636
					    0);
					did_range_unmap = 1;
				} else {
					/*
					 * Just zap this page
					 */
					unmap_mapping_range(mapping,
637 638
					   (loff_t)index << PAGE_CACHE_SHIFT,
					   PAGE_CACHE_SIZE, 0);
L
Linus Torvalds 已提交
639 640
				}
			}
641
			BUG_ON(page_mapped(page));
642 643 644
			ret2 = do_launder_page(mapping, page);
			if (ret2 == 0) {
				if (!invalidate_complete_page2(mapping, page))
645
					ret2 = -EBUSY;
646 647 648
			}
			if (ret2 < 0)
				ret = ret2;
L
Linus Torvalds 已提交
649 650
			unlock_page(page);
		}
651
		pagevec_remove_exceptionals(&pvec);
L
Linus Torvalds 已提交
652
		pagevec_release(&pvec);
653
		mem_cgroup_uncharge_end();
L
Linus Torvalds 已提交
654
		cond_resched();
655
		index++;
L
Linus Torvalds 已提交
656
	}
657
	cleancache_invalidate_inode(mapping);
L
Linus Torvalds 已提交
658 659 660 661 662 663
	return ret;
}
EXPORT_SYMBOL_GPL(invalidate_inode_pages2_range);

/**
 * invalidate_inode_pages2 - remove all pages from an address_space
664
 * @mapping: the address_space
L
Linus Torvalds 已提交
665 666 667 668
 *
 * Any pages which are found to be mapped into pagetables are unmapped prior to
 * invalidation.
 *
669
 * Returns -EBUSY if any pages could not be invalidated.
L
Linus Torvalds 已提交
670 671 672 673 674 675
 */
int invalidate_inode_pages2(struct address_space *mapping)
{
	return invalidate_inode_pages2_range(mapping, 0, -1);
}
EXPORT_SYMBOL_GPL(invalidate_inode_pages2);
N
npiggin@suse.de 已提交
676 677 678 679

/**
 * truncate_pagecache - unmap and remove pagecache that has been truncated
 * @inode: inode
680
 * @newsize: new file size
N
npiggin@suse.de 已提交
681 682 683 684 685 686 687 688 689 690 691
 *
 * inode's new i_size must already be written before truncate_pagecache
 * is called.
 *
 * This function should typically be called before the filesystem
 * releases resources associated with the freed range (eg. deallocates
 * blocks). This way, pagecache will always stay logically coherent
 * with on-disk format, and the filesystem would not have to deal with
 * situations such as writepage being called for a page that has already
 * had its underlying blocks deallocated.
 */
692
void truncate_pagecache(struct inode *inode, loff_t newsize)
N
npiggin@suse.de 已提交
693
{
694
	struct address_space *mapping = inode->i_mapping;
695
	loff_t holebegin = round_up(newsize, PAGE_SIZE);
696 697 698 699 700 701 702 703 704 705

	/*
	 * unmap_mapping_range is called twice, first simply for
	 * efficiency so that truncate_inode_pages does fewer
	 * single-page unmaps.  However after this first call, and
	 * before truncate_inode_pages finishes, it is possible for
	 * private pages to be COWed, which remain after
	 * truncate_inode_pages finishes, hence the second
	 * unmap_mapping_range call must be made for correctness.
	 */
706 707 708
	unmap_mapping_range(mapping, holebegin, 0, 1);
	truncate_inode_pages(mapping, newsize);
	unmap_mapping_range(mapping, holebegin, 0, 1);
N
npiggin@suse.de 已提交
709 710 711
}
EXPORT_SYMBOL(truncate_pagecache);

712 713 714 715 716
/**
 * truncate_setsize - update inode and pagecache for a new file size
 * @inode: inode
 * @newsize: new file size
 *
J
Jan Kara 已提交
717 718 719
 * truncate_setsize updates i_size and performs pagecache truncation (if
 * necessary) to @newsize. It will be typically be called from the filesystem's
 * setattr function when ATTR_SIZE is passed in.
720
 *
J
Jan Kara 已提交
721 722
 * Must be called with inode_mutex held and before all filesystem specific
 * block truncation has been performed.
723 724 725 726
 */
void truncate_setsize(struct inode *inode, loff_t newsize)
{
	i_size_write(inode, newsize);
727
	truncate_pagecache(inode, newsize);
728 729 730
}
EXPORT_SYMBOL(truncate_setsize);

731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
/**
 * truncate_pagecache_range - unmap and remove pagecache that is hole-punched
 * @inode: inode
 * @lstart: offset of beginning of hole
 * @lend: offset of last byte of hole
 *
 * This function should typically be called before the filesystem
 * releases resources associated with the freed range (eg. deallocates
 * blocks). This way, pagecache will always stay logically coherent
 * with on-disk format, and the filesystem would not have to deal with
 * situations such as writepage being called for a page that has already
 * had its underlying blocks deallocated.
 */
void truncate_pagecache_range(struct inode *inode, loff_t lstart, loff_t lend)
{
	struct address_space *mapping = inode->i_mapping;
	loff_t unmap_start = round_up(lstart, PAGE_SIZE);
	loff_t unmap_end = round_down(1 + lend, PAGE_SIZE) - 1;
	/*
	 * This rounding is currently just for example: unmap_mapping_range
	 * expands its hole outwards, whereas we want it to contract the hole
	 * inwards.  However, existing callers of truncate_pagecache_range are
753 754
	 * doing their own page rounding first.  Note that unmap_mapping_range
	 * allows holelen 0 for all, and we allow lend -1 for end of file.
755 756 757 758 759 760 761 762 763 764 765 766 767
	 */

	/*
	 * Unlike in truncate_pagecache, unmap_mapping_range is called only
	 * once (before truncating pagecache), and without "even_cows" flag:
	 * hole-punching should not remove private COWed pages from the hole.
	 */
	if ((u64)unmap_end > (u64)unmap_start)
		unmap_mapping_range(mapping, unmap_start,
				    1 + unmap_end - unmap_start, 0);
	truncate_inode_pages_range(mapping, lstart, lend);
}
EXPORT_SYMBOL(truncate_pagecache_range);