Merge branch 'pm-cpuidle'
[firefly-linux-kernel-4.4.55.git] / mm / truncate.c
1 /*
2  * mm/truncate.c - code for taking down pages from address_spaces
3  *
4  * Copyright (C) 2002, Linus Torvalds
5  *
6  * 10Sep2002    Andrew Morton
7  *              Initial version.
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/backing-dev.h>
12 #include <linux/gfp.h>
13 #include <linux/mm.h>
14 #include <linux/swap.h>
15 #include <linux/export.h>
16 #include <linux/pagemap.h>
17 #include <linux/highmem.h>
18 #include <linux/pagevec.h>
19 #include <linux/task_io_accounting_ops.h>
20 #include <linux/buffer_head.h>  /* grr. try_to_release_page,
21                                    do_invalidatepage */
22 #include <linux/cleancache.h>
23 #include "internal.h"
24
25 static void clear_exceptional_entry(struct address_space *mapping,
26                                     pgoff_t index, void *entry)
27 {
28         struct radix_tree_node *node;
29         void **slot;
30
31         /* Handled by shmem itself */
32         if (shmem_mapping(mapping))
33                 return;
34
35         spin_lock_irq(&mapping->tree_lock);
36         /*
37          * Regular page slots are stabilized by the page lock even
38          * without the tree itself locked.  These unlocked entries
39          * need verification under the tree lock.
40          */
41         if (!__radix_tree_lookup(&mapping->page_tree, index, &node, &slot))
42                 goto unlock;
43         if (*slot != entry)
44                 goto unlock;
45         radix_tree_replace_slot(slot, NULL);
46         mapping->nrshadows--;
47         if (!node)
48                 goto unlock;
49         workingset_node_shadows_dec(node);
50         /*
51          * Don't track node without shadow entries.
52          *
53          * Avoid acquiring the list_lru lock if already untracked.
54          * The list_empty() test is safe as node->private_list is
55          * protected by mapping->tree_lock.
56          */
57         if (!workingset_node_shadows(node) &&
58             !list_empty(&node->private_list))
59                 list_lru_del(&workingset_shadow_nodes, &node->private_list);
60         __radix_tree_delete_node(&mapping->page_tree, node);
61 unlock:
62         spin_unlock_irq(&mapping->tree_lock);
63 }
64
65 /**
66  * do_invalidatepage - invalidate part or all of a page
67  * @page: the page which is affected
68  * @offset: start of the range to invalidate
69  * @length: length of the range to invalidate
70  *
71  * do_invalidatepage() is called when all or part of the page has become
72  * invalidated by a truncate operation.
73  *
74  * do_invalidatepage() does not have to release all buffers, but it must
75  * ensure that no dirty buffer is left outside @offset and that no I/O
76  * is underway against any of the blocks which are outside the truncation
77  * point.  Because the caller is about to free (and possibly reuse) those
78  * blocks on-disk.
79  */
80 void do_invalidatepage(struct page *page, unsigned int offset,
81                        unsigned int length)
82 {
83         void (*invalidatepage)(struct page *, unsigned int, unsigned int);
84
85         invalidatepage = page->mapping->a_ops->invalidatepage;
86 #ifdef CONFIG_BLOCK
87         if (!invalidatepage)
88                 invalidatepage = block_invalidatepage;
89 #endif
90         if (invalidatepage)
91                 (*invalidatepage)(page, offset, length);
92 }
93
94 /*
95  * This cancels just the dirty bit on the kernel page itself, it
96  * does NOT actually remove dirty bits on any mmap's that may be
97  * around. It also leaves the page tagged dirty, so any sync
98  * activity will still find it on the dirty lists, and in particular,
99  * clear_page_dirty_for_io() will still look at the dirty bits in
100  * the VM.
101  *
102  * Doing this should *normally* only ever be done when a page
103  * is truncated, and is not actually mapped anywhere at all. However,
104  * fs/buffer.c does this when it notices that somebody has cleaned
105  * out all the buffers on a page without actually doing it through
106  * the VM. Can you say "ext3 is horribly ugly"? Tought you could.
107  */
108 void cancel_dirty_page(struct page *page, unsigned int account_size)
109 {
110         if (TestClearPageDirty(page)) {
111                 struct address_space *mapping = page->mapping;
112                 if (mapping && mapping_cap_account_dirty(mapping)) {
113                         dec_zone_page_state(page, NR_FILE_DIRTY);
114                         dec_bdi_stat(mapping->backing_dev_info,
115                                         BDI_RECLAIMABLE);
116                         if (account_size)
117                                 task_io_account_cancelled_write(account_size);
118                 }
119         }
120 }
121 EXPORT_SYMBOL(cancel_dirty_page);
122
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().
127  *
128  * We need to bale out if page->mapping is no longer equal to the original
129  * 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
131  * c) when tmpfs swizzles a page between a tmpfs inode and swapper_space.
132  */
133 static int
134 truncate_complete_page(struct address_space *mapping, struct page *page)
135 {
136         if (page->mapping != mapping)
137                 return -EIO;
138
139         if (page_has_private(page))
140                 do_invalidatepage(page, 0, PAGE_CACHE_SIZE);
141
142         cancel_dirty_page(page, PAGE_CACHE_SIZE);
143
144         ClearPageMappedToDisk(page);
145         delete_from_page_cache(page);
146         return 0;
147 }
148
149 /*
150  * This is for invalidate_mapping_pages().  That function can be called at
151  * any time, and is not supposed to throw away dirty pages.  But pages can
152  * be marked dirty at any time too, so use remove_mapping which safely
153  * discards clean, unused pages.
154  *
155  * Returns non-zero if the page was successfully invalidated.
156  */
157 static int
158 invalidate_complete_page(struct address_space *mapping, struct page *page)
159 {
160         int ret;
161
162         if (page->mapping != mapping)
163                 return 0;
164
165         if (page_has_private(page) && !try_to_release_page(page, 0))
166                 return 0;
167
168         ret = remove_mapping(mapping, page);
169
170         return ret;
171 }
172
173 int truncate_inode_page(struct address_space *mapping, struct page *page)
174 {
175         if (page_mapped(page)) {
176                 unmap_mapping_range(mapping,
177                                    (loff_t)page->index << PAGE_CACHE_SHIFT,
178                                    PAGE_CACHE_SIZE, 0);
179         }
180         return truncate_complete_page(mapping, page);
181 }
182
183 /*
184  * Used to get rid of pages on hardware memory corruption.
185  */
186 int generic_error_remove_page(struct address_space *mapping, struct page *page)
187 {
188         if (!mapping)
189                 return -EINVAL;
190         /*
191          * Only punch for normal data pages for now.
192          * Handling other types like directories would need more auditing.
193          */
194         if (!S_ISREG(mapping->host->i_mode))
195                 return -EIO;
196         return truncate_inode_page(mapping, page);
197 }
198 EXPORT_SYMBOL(generic_error_remove_page);
199
200 /*
201  * Safely invalidate one page from its pagecache mapping.
202  * It only drops clean, unused pages. The page must be locked.
203  *
204  * Returns 1 if the page is successfully invalidated, otherwise 0.
205  */
206 int invalidate_inode_page(struct page *page)
207 {
208         struct address_space *mapping = page_mapping(page);
209         if (!mapping)
210                 return 0;
211         if (PageDirty(page) || PageWriteback(page))
212                 return 0;
213         if (page_mapped(page))
214                 return 0;
215         return invalidate_complete_page(mapping, page);
216 }
217
218 /**
219  * truncate_inode_pages_range - truncate range of pages specified by start & end byte offsets
220  * @mapping: mapping to truncate
221  * @lstart: offset from which to truncate
222  * @lend: offset to which to truncate (inclusive)
223  *
224  * Truncate the page cache, removing the pages that are between
225  * specified offsets (and zeroing out partial pages
226  * if lstart or lend + 1 is not page aligned).
227  *
228  * Truncate takes two passes - the first pass is nonblocking.  It will not
229  * block on page locks and it will not block on writeback.  The second pass
230  * will wait.  This is to prevent as much IO as possible in the affected region.
231  * The first pass will remove most pages, so the search cost of the second pass
232  * is low.
233  *
234  * We pass down the cache-hot hint to the page freeing code.  Even if the
235  * mapping is large, it is probably the case that the final pages are the most
236  * recently touched, and freeing happens in ascending file offset order.
237  *
238  * Note that since ->invalidatepage() accepts range to invalidate
239  * truncate_inode_pages_range is able to handle cases where lend + 1 is not
240  * page aligned properly.
241  */
242 void truncate_inode_pages_range(struct address_space *mapping,
243                                 loff_t lstart, loff_t lend)
244 {
245         pgoff_t         start;          /* inclusive */
246         pgoff_t         end;            /* exclusive */
247         unsigned int    partial_start;  /* inclusive */
248         unsigned int    partial_end;    /* exclusive */
249         struct pagevec  pvec;
250         pgoff_t         indices[PAGEVEC_SIZE];
251         pgoff_t         index;
252         int             i;
253
254         cleancache_invalidate_inode(mapping);
255         if (mapping->nrpages == 0 && mapping->nrshadows == 0)
256                 return;
257
258         /* Offsets within partial pages */
259         partial_start = lstart & (PAGE_CACHE_SIZE - 1);
260         partial_end = (lend + 1) & (PAGE_CACHE_SIZE - 1);
261
262         /*
263          * 'start' and 'end' always covers the range of pages to be fully
264          * truncated. Partial pages are covered with 'partial_start' at the
265          * start of the range and 'partial_end' at the end of the range.
266          * Note that 'end' is exclusive while 'lend' is inclusive.
267          */
268         start = (lstart + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
269         if (lend == -1)
270                 /*
271                  * lend == -1 indicates end-of-file so we have to set 'end'
272                  * to the highest possible pgoff_t and since the type is
273                  * unsigned we're using -1.
274                  */
275                 end = -1;
276         else
277                 end = (lend + 1) >> PAGE_CACHE_SHIFT;
278
279         pagevec_init(&pvec, 0);
280         index = start;
281         while (index < end && pagevec_lookup_entries(&pvec, mapping, index,
282                         min(end - index, (pgoff_t)PAGEVEC_SIZE),
283                         indices)) {
284                 mem_cgroup_uncharge_start();
285                 for (i = 0; i < pagevec_count(&pvec); i++) {
286                         struct page *page = pvec.pages[i];
287
288                         /* We rely upon deletion not changing page->index */
289                         index = indices[i];
290                         if (index >= end)
291                                 break;
292
293                         if (radix_tree_exceptional_entry(page)) {
294                                 clear_exceptional_entry(mapping, index, page);
295                                 continue;
296                         }
297
298                         if (!trylock_page(page))
299                                 continue;
300                         WARN_ON(page->index != index);
301                         if (PageWriteback(page)) {
302                                 unlock_page(page);
303                                 continue;
304                         }
305                         truncate_inode_page(mapping, page);
306                         unlock_page(page);
307                 }
308                 pagevec_remove_exceptionals(&pvec);
309                 pagevec_release(&pvec);
310                 mem_cgroup_uncharge_end();
311                 cond_resched();
312                 index++;
313         }
314
315         if (partial_start) {
316                 struct page *page = find_lock_page(mapping, start - 1);
317                 if (page) {
318                         unsigned int top = PAGE_CACHE_SIZE;
319                         if (start > end) {
320                                 /* Truncation within a single page */
321                                 top = partial_end;
322                                 partial_end = 0;
323                         }
324                         wait_on_page_writeback(page);
325                         zero_user_segment(page, partial_start, top);
326                         cleancache_invalidate_page(mapping, page);
327                         if (page_has_private(page))
328                                 do_invalidatepage(page, partial_start,
329                                                   top - partial_start);
330                         unlock_page(page);
331                         page_cache_release(page);
332                 }
333         }
334         if (partial_end) {
335                 struct page *page = find_lock_page(mapping, end);
336                 if (page) {
337                         wait_on_page_writeback(page);
338                         zero_user_segment(page, 0, partial_end);
339                         cleancache_invalidate_page(mapping, page);
340                         if (page_has_private(page))
341                                 do_invalidatepage(page, 0,
342                                                   partial_end);
343                         unlock_page(page);
344                         page_cache_release(page);
345                 }
346         }
347         /*
348          * If the truncation happened within a single page no pages
349          * will be released, just zeroed, so we can bail out now.
350          */
351         if (start >= end)
352                 return;
353
354         index = start;
355         for ( ; ; ) {
356                 cond_resched();
357                 if (!pagevec_lookup_entries(&pvec, mapping, index,
358                         min(end - index, (pgoff_t)PAGEVEC_SIZE), indices)) {
359                         /* If all gone from start onwards, we're done */
360                         if (index == start)
361                                 break;
362                         /* Otherwise restart to make sure all gone */
363                         index = start;
364                         continue;
365                 }
366                 if (index == start && indices[0] >= end) {
367                         /* All gone out of hole to be punched, we're done */
368                         pagevec_remove_exceptionals(&pvec);
369                         pagevec_release(&pvec);
370                         break;
371                 }
372                 mem_cgroup_uncharge_start();
373                 for (i = 0; i < pagevec_count(&pvec); i++) {
374                         struct page *page = pvec.pages[i];
375
376                         /* We rely upon deletion not changing page->index */
377                         index = indices[i];
378                         if (index >= end) {
379                                 /* Restart punch to make sure all gone */
380                                 index = start - 1;
381                                 break;
382                         }
383
384                         if (radix_tree_exceptional_entry(page)) {
385                                 clear_exceptional_entry(mapping, index, page);
386                                 continue;
387                         }
388
389                         lock_page(page);
390                         WARN_ON(page->index != index);
391                         wait_on_page_writeback(page);
392                         truncate_inode_page(mapping, page);
393                         unlock_page(page);
394                 }
395                 pagevec_remove_exceptionals(&pvec);
396                 pagevec_release(&pvec);
397                 mem_cgroup_uncharge_end();
398                 index++;
399         }
400         cleancache_invalidate_inode(mapping);
401 }
402 EXPORT_SYMBOL(truncate_inode_pages_range);
403
404 /**
405  * truncate_inode_pages - truncate *all* the pages from an offset
406  * @mapping: mapping to truncate
407  * @lstart: offset from which to truncate
408  *
409  * Called under (and serialised by) inode->i_mutex.
410  *
411  * Note: When this function returns, there can be a page in the process of
412  * deletion (inside __delete_from_page_cache()) in the specified range.  Thus
413  * mapping->nrpages can be non-zero when this function returns even after
414  * truncation of the whole mapping.
415  */
416 void truncate_inode_pages(struct address_space *mapping, loff_t lstart)
417 {
418         truncate_inode_pages_range(mapping, lstart, (loff_t)-1);
419 }
420 EXPORT_SYMBOL(truncate_inode_pages);
421
422 /**
423  * truncate_inode_pages_final - truncate *all* pages before inode dies
424  * @mapping: mapping to truncate
425  *
426  * Called under (and serialized by) inode->i_mutex.
427  *
428  * Filesystems have to use this in the .evict_inode path to inform the
429  * VM that this is the final truncate and the inode is going away.
430  */
431 void truncate_inode_pages_final(struct address_space *mapping)
432 {
433         unsigned long nrshadows;
434         unsigned long nrpages;
435
436         /*
437          * Page reclaim can not participate in regular inode lifetime
438          * management (can't call iput()) and thus can race with the
439          * inode teardown.  Tell it when the address space is exiting,
440          * so that it does not install eviction information after the
441          * final truncate has begun.
442          */
443         mapping_set_exiting(mapping);
444
445         /*
446          * When reclaim installs eviction entries, it increases
447          * nrshadows first, then decreases nrpages.  Make sure we see
448          * this in the right order or we might miss an entry.
449          */
450         nrpages = mapping->nrpages;
451         smp_rmb();
452         nrshadows = mapping->nrshadows;
453
454         if (nrpages || nrshadows) {
455                 /*
456                  * As truncation uses a lockless tree lookup, cycle
457                  * the tree lock to make sure any ongoing tree
458                  * modification that does not see AS_EXITING is
459                  * completed before starting the final truncate.
460                  */
461                 spin_lock_irq(&mapping->tree_lock);
462                 spin_unlock_irq(&mapping->tree_lock);
463
464                 truncate_inode_pages(mapping, 0);
465         }
466 }
467 EXPORT_SYMBOL(truncate_inode_pages_final);
468
469 /**
470  * invalidate_mapping_pages - Invalidate all the unlocked pages of one inode
471  * @mapping: the address_space which holds the pages to invalidate
472  * @start: the offset 'from' which to invalidate
473  * @end: the offset 'to' which to invalidate (inclusive)
474  *
475  * This function only removes the unlocked pages, if you want to
476  * remove all the pages of one inode, you must call truncate_inode_pages.
477  *
478  * invalidate_mapping_pages() will not block on IO activity. It will not
479  * invalidate pages which are dirty, locked, under writeback or mapped into
480  * pagetables.
481  */
482 unsigned long invalidate_mapping_pages(struct address_space *mapping,
483                 pgoff_t start, pgoff_t end)
484 {
485         pgoff_t indices[PAGEVEC_SIZE];
486         struct pagevec pvec;
487         pgoff_t index = start;
488         unsigned long ret;
489         unsigned long count = 0;
490         int i;
491
492         pagevec_init(&pvec, 0);
493         while (index <= end && pagevec_lookup_entries(&pvec, mapping, index,
494                         min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1,
495                         indices)) {
496                 mem_cgroup_uncharge_start();
497                 for (i = 0; i < pagevec_count(&pvec); i++) {
498                         struct page *page = pvec.pages[i];
499
500                         /* We rely upon deletion not changing page->index */
501                         index = indices[i];
502                         if (index > end)
503                                 break;
504
505                         if (radix_tree_exceptional_entry(page)) {
506                                 clear_exceptional_entry(mapping, index, page);
507                                 continue;
508                         }
509
510                         if (!trylock_page(page))
511                                 continue;
512                         WARN_ON(page->index != index);
513                         ret = invalidate_inode_page(page);
514                         unlock_page(page);
515                         /*
516                          * Invalidation is a hint that the page is no longer
517                          * of interest and try to speed up its reclaim.
518                          */
519                         if (!ret)
520                                 deactivate_page(page);
521                         count += ret;
522                 }
523                 pagevec_remove_exceptionals(&pvec);
524                 pagevec_release(&pvec);
525                 mem_cgroup_uncharge_end();
526                 cond_resched();
527                 index++;
528         }
529         return count;
530 }
531 EXPORT_SYMBOL(invalidate_mapping_pages);
532
533 /*
534  * This is like invalidate_complete_page(), except it ignores the page's
535  * refcount.  We do this because invalidate_inode_pages2() needs stronger
536  * invalidation guarantees, and cannot afford to leave pages behind because
537  * shrink_page_list() has a temp ref on them, or because they're transiently
538  * sitting in the lru_cache_add() pagevecs.
539  */
540 static int
541 invalidate_complete_page2(struct address_space *mapping, struct page *page)
542 {
543         if (page->mapping != mapping)
544                 return 0;
545
546         if (page_has_private(page) && !try_to_release_page(page, GFP_KERNEL))
547                 return 0;
548
549         spin_lock_irq(&mapping->tree_lock);
550         if (PageDirty(page))
551                 goto failed;
552
553         BUG_ON(page_has_private(page));
554         __delete_from_page_cache(page, NULL);
555         spin_unlock_irq(&mapping->tree_lock);
556         mem_cgroup_uncharge_cache_page(page);
557
558         if (mapping->a_ops->freepage)
559                 mapping->a_ops->freepage(page);
560
561         page_cache_release(page);       /* pagecache ref */
562         return 1;
563 failed:
564         spin_unlock_irq(&mapping->tree_lock);
565         return 0;
566 }
567
568 static int do_launder_page(struct address_space *mapping, struct page *page)
569 {
570         if (!PageDirty(page))
571                 return 0;
572         if (page->mapping != mapping || mapping->a_ops->launder_page == NULL)
573                 return 0;
574         return mapping->a_ops->launder_page(page);
575 }
576
577 /**
578  * invalidate_inode_pages2_range - remove range of pages from an address_space
579  * @mapping: the address_space
580  * @start: the page offset 'from' which to invalidate
581  * @end: the page offset 'to' which to invalidate (inclusive)
582  *
583  * Any pages which are found to be mapped into pagetables are unmapped prior to
584  * invalidation.
585  *
586  * Returns -EBUSY if any pages could not be invalidated.
587  */
588 int invalidate_inode_pages2_range(struct address_space *mapping,
589                                   pgoff_t start, pgoff_t end)
590 {
591         pgoff_t indices[PAGEVEC_SIZE];
592         struct pagevec pvec;
593         pgoff_t index;
594         int i;
595         int ret = 0;
596         int ret2 = 0;
597         int did_range_unmap = 0;
598
599         cleancache_invalidate_inode(mapping);
600         pagevec_init(&pvec, 0);
601         index = start;
602         while (index <= end && pagevec_lookup_entries(&pvec, mapping, index,
603                         min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1,
604                         indices)) {
605                 mem_cgroup_uncharge_start();
606                 for (i = 0; i < pagevec_count(&pvec); i++) {
607                         struct page *page = pvec.pages[i];
608
609                         /* We rely upon deletion not changing page->index */
610                         index = indices[i];
611                         if (index > end)
612                                 break;
613
614                         if (radix_tree_exceptional_entry(page)) {
615                                 clear_exceptional_entry(mapping, index, page);
616                                 continue;
617                         }
618
619                         lock_page(page);
620                         WARN_ON(page->index != index);
621                         if (page->mapping != mapping) {
622                                 unlock_page(page);
623                                 continue;
624                         }
625                         wait_on_page_writeback(page);
626                         if (page_mapped(page)) {
627                                 if (!did_range_unmap) {
628                                         /*
629                                          * Zap the rest of the file in one hit.
630                                          */
631                                         unmap_mapping_range(mapping,
632                                            (loff_t)index << PAGE_CACHE_SHIFT,
633                                            (loff_t)(1 + end - index)
634                                                          << PAGE_CACHE_SHIFT,
635                                             0);
636                                         did_range_unmap = 1;
637                                 } else {
638                                         /*
639                                          * Just zap this page
640                                          */
641                                         unmap_mapping_range(mapping,
642                                            (loff_t)index << PAGE_CACHE_SHIFT,
643                                            PAGE_CACHE_SIZE, 0);
644                                 }
645                         }
646                         BUG_ON(page_mapped(page));
647                         ret2 = do_launder_page(mapping, page);
648                         if (ret2 == 0) {
649                                 if (!invalidate_complete_page2(mapping, page))
650                                         ret2 = -EBUSY;
651                         }
652                         if (ret2 < 0)
653                                 ret = ret2;
654                         unlock_page(page);
655                 }
656                 pagevec_remove_exceptionals(&pvec);
657                 pagevec_release(&pvec);
658                 mem_cgroup_uncharge_end();
659                 cond_resched();
660                 index++;
661         }
662         cleancache_invalidate_inode(mapping);
663         return ret;
664 }
665 EXPORT_SYMBOL_GPL(invalidate_inode_pages2_range);
666
667 /**
668  * invalidate_inode_pages2 - remove all pages from an address_space
669  * @mapping: the address_space
670  *
671  * Any pages which are found to be mapped into pagetables are unmapped prior to
672  * invalidation.
673  *
674  * Returns -EBUSY if any pages could not be invalidated.
675  */
676 int invalidate_inode_pages2(struct address_space *mapping)
677 {
678         return invalidate_inode_pages2_range(mapping, 0, -1);
679 }
680 EXPORT_SYMBOL_GPL(invalidate_inode_pages2);
681
682 /**
683  * truncate_pagecache - unmap and remove pagecache that has been truncated
684  * @inode: inode
685  * @newsize: new file size
686  *
687  * inode's new i_size must already be written before truncate_pagecache
688  * is called.
689  *
690  * This function should typically be called before the filesystem
691  * releases resources associated with the freed range (eg. deallocates
692  * blocks). This way, pagecache will always stay logically coherent
693  * with on-disk format, and the filesystem would not have to deal with
694  * situations such as writepage being called for a page that has already
695  * had its underlying blocks deallocated.
696  */
697 void truncate_pagecache(struct inode *inode, loff_t newsize)
698 {
699         struct address_space *mapping = inode->i_mapping;
700         loff_t holebegin = round_up(newsize, PAGE_SIZE);
701
702         /*
703          * unmap_mapping_range is called twice, first simply for
704          * efficiency so that truncate_inode_pages does fewer
705          * single-page unmaps.  However after this first call, and
706          * before truncate_inode_pages finishes, it is possible for
707          * private pages to be COWed, which remain after
708          * truncate_inode_pages finishes, hence the second
709          * unmap_mapping_range call must be made for correctness.
710          */
711         unmap_mapping_range(mapping, holebegin, 0, 1);
712         truncate_inode_pages(mapping, newsize);
713         unmap_mapping_range(mapping, holebegin, 0, 1);
714 }
715 EXPORT_SYMBOL(truncate_pagecache);
716
717 /**
718  * truncate_setsize - update inode and pagecache for a new file size
719  * @inode: inode
720  * @newsize: new file size
721  *
722  * truncate_setsize updates i_size and performs pagecache truncation (if
723  * necessary) to @newsize. It will be typically be called from the filesystem's
724  * setattr function when ATTR_SIZE is passed in.
725  *
726  * Must be called with inode_mutex held and before all filesystem specific
727  * block truncation has been performed.
728  */
729 void truncate_setsize(struct inode *inode, loff_t newsize)
730 {
731         i_size_write(inode, newsize);
732         truncate_pagecache(inode, newsize);
733 }
734 EXPORT_SYMBOL(truncate_setsize);
735
736 /**
737  * truncate_pagecache_range - unmap and remove pagecache that is hole-punched
738  * @inode: inode
739  * @lstart: offset of beginning of hole
740  * @lend: offset of last byte of hole
741  *
742  * This function should typically be called before the filesystem
743  * releases resources associated with the freed range (eg. deallocates
744  * blocks). This way, pagecache will always stay logically coherent
745  * with on-disk format, and the filesystem would not have to deal with
746  * situations such as writepage being called for a page that has already
747  * had its underlying blocks deallocated.
748  */
749 void truncate_pagecache_range(struct inode *inode, loff_t lstart, loff_t lend)
750 {
751         struct address_space *mapping = inode->i_mapping;
752         loff_t unmap_start = round_up(lstart, PAGE_SIZE);
753         loff_t unmap_end = round_down(1 + lend, PAGE_SIZE) - 1;
754         /*
755          * This rounding is currently just for example: unmap_mapping_range
756          * expands its hole outwards, whereas we want it to contract the hole
757          * inwards.  However, existing callers of truncate_pagecache_range are
758          * doing their own page rounding first.  Note that unmap_mapping_range
759          * allows holelen 0 for all, and we allow lend -1 for end of file.
760          */
761
762         /*
763          * Unlike in truncate_pagecache, unmap_mapping_range is called only
764          * once (before truncating pagecache), and without "even_cows" flag:
765          * hole-punching should not remove private COWed pages from the hole.
766          */
767         if ((u64)unmap_end > (u64)unmap_start)
768                 unmap_mapping_range(mapping, unmap_start,
769                                     1 + unmap_end - unmap_start, 0);
770         truncate_inode_pages_range(mapping, lstart, lend);
771 }
772 EXPORT_SYMBOL(truncate_pagecache_range);