cifs: don't instantiate new dentries in readdir for inodes that need to be revalidate...
[linux-3.10.git] / fs / nilfs2 / page.c
1 /*
2  * page.c - buffer/page management specific to NILFS
3  *
4  * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * Written by Ryusuke Konishi <ryusuke@osrg.net>,
21  *            Seiji Kihara <kihara@osrg.net>.
22  */
23
24 #include <linux/pagemap.h>
25 #include <linux/writeback.h>
26 #include <linux/swap.h>
27 #include <linux/bitops.h>
28 #include <linux/page-flags.h>
29 #include <linux/list.h>
30 #include <linux/highmem.h>
31 #include <linux/pagevec.h>
32 #include <linux/gfp.h>
33 #include "nilfs.h"
34 #include "page.h"
35 #include "mdt.h"
36
37
38 #define NILFS_BUFFER_INHERENT_BITS  \
39         ((1UL << BH_Uptodate) | (1UL << BH_Mapped) | (1UL << BH_NILFS_Node) | \
40          (1UL << BH_NILFS_Volatile) | (1UL << BH_NILFS_Checked))
41
42 static struct buffer_head *
43 __nilfs_get_page_block(struct page *page, unsigned long block, pgoff_t index,
44                        int blkbits, unsigned long b_state)
45
46 {
47         unsigned long first_block;
48         struct buffer_head *bh;
49
50         if (!page_has_buffers(page))
51                 create_empty_buffers(page, 1 << blkbits, b_state);
52
53         first_block = (unsigned long)index << (PAGE_CACHE_SHIFT - blkbits);
54         bh = nilfs_page_get_nth_block(page, block - first_block);
55
56         touch_buffer(bh);
57         wait_on_buffer(bh);
58         return bh;
59 }
60
61 struct buffer_head *nilfs_grab_buffer(struct inode *inode,
62                                       struct address_space *mapping,
63                                       unsigned long blkoff,
64                                       unsigned long b_state)
65 {
66         int blkbits = inode->i_blkbits;
67         pgoff_t index = blkoff >> (PAGE_CACHE_SHIFT - blkbits);
68         struct page *page;
69         struct buffer_head *bh;
70
71         page = grab_cache_page(mapping, index);
72         if (unlikely(!page))
73                 return NULL;
74
75         bh = __nilfs_get_page_block(page, blkoff, index, blkbits, b_state);
76         if (unlikely(!bh)) {
77                 unlock_page(page);
78                 page_cache_release(page);
79                 return NULL;
80         }
81         return bh;
82 }
83
84 /**
85  * nilfs_forget_buffer - discard dirty state
86  * @inode: owner inode of the buffer
87  * @bh: buffer head of the buffer to be discarded
88  */
89 void nilfs_forget_buffer(struct buffer_head *bh)
90 {
91         struct page *page = bh->b_page;
92
93         lock_buffer(bh);
94         clear_buffer_nilfs_volatile(bh);
95         clear_buffer_nilfs_checked(bh);
96         clear_buffer_nilfs_redirected(bh);
97         clear_buffer_dirty(bh);
98         if (nilfs_page_buffers_clean(page))
99                 __nilfs_clear_page_dirty(page);
100
101         clear_buffer_uptodate(bh);
102         clear_buffer_mapped(bh);
103         bh->b_blocknr = -1;
104         ClearPageUptodate(page);
105         ClearPageMappedToDisk(page);
106         unlock_buffer(bh);
107         brelse(bh);
108 }
109
110 /**
111  * nilfs_copy_buffer -- copy buffer data and flags
112  * @dbh: destination buffer
113  * @sbh: source buffer
114  */
115 void nilfs_copy_buffer(struct buffer_head *dbh, struct buffer_head *sbh)
116 {
117         void *kaddr0, *kaddr1;
118         unsigned long bits;
119         struct page *spage = sbh->b_page, *dpage = dbh->b_page;
120         struct buffer_head *bh;
121
122         kaddr0 = kmap_atomic(spage);
123         kaddr1 = kmap_atomic(dpage);
124         memcpy(kaddr1 + bh_offset(dbh), kaddr0 + bh_offset(sbh), sbh->b_size);
125         kunmap_atomic(kaddr1);
126         kunmap_atomic(kaddr0);
127
128         dbh->b_state = sbh->b_state & NILFS_BUFFER_INHERENT_BITS;
129         dbh->b_blocknr = sbh->b_blocknr;
130         dbh->b_bdev = sbh->b_bdev;
131
132         bh = dbh;
133         bits = sbh->b_state & ((1UL << BH_Uptodate) | (1UL << BH_Mapped));
134         while ((bh = bh->b_this_page) != dbh) {
135                 lock_buffer(bh);
136                 bits &= bh->b_state;
137                 unlock_buffer(bh);
138         }
139         if (bits & (1UL << BH_Uptodate))
140                 SetPageUptodate(dpage);
141         else
142                 ClearPageUptodate(dpage);
143         if (bits & (1UL << BH_Mapped))
144                 SetPageMappedToDisk(dpage);
145         else
146                 ClearPageMappedToDisk(dpage);
147 }
148
149 /**
150  * nilfs_page_buffers_clean - check if a page has dirty buffers or not.
151  * @page: page to be checked
152  *
153  * nilfs_page_buffers_clean() returns zero if the page has dirty buffers.
154  * Otherwise, it returns non-zero value.
155  */
156 int nilfs_page_buffers_clean(struct page *page)
157 {
158         struct buffer_head *bh, *head;
159
160         bh = head = page_buffers(page);
161         do {
162                 if (buffer_dirty(bh))
163                         return 0;
164                 bh = bh->b_this_page;
165         } while (bh != head);
166         return 1;
167 }
168
169 void nilfs_page_bug(struct page *page)
170 {
171         struct address_space *m;
172         unsigned long ino;
173
174         if (unlikely(!page)) {
175                 printk(KERN_CRIT "NILFS_PAGE_BUG(NULL)\n");
176                 return;
177         }
178
179         m = page->mapping;
180         ino = m ? m->host->i_ino : 0;
181
182         printk(KERN_CRIT "NILFS_PAGE_BUG(%p): cnt=%d index#=%llu flags=0x%lx "
183                "mapping=%p ino=%lu\n",
184                page, atomic_read(&page->_count),
185                (unsigned long long)page->index, page->flags, m, ino);
186
187         if (page_has_buffers(page)) {
188                 struct buffer_head *bh, *head;
189                 int i = 0;
190
191                 bh = head = page_buffers(page);
192                 do {
193                         printk(KERN_CRIT
194                                " BH[%d] %p: cnt=%d block#=%llu state=0x%lx\n",
195                                i++, bh, atomic_read(&bh->b_count),
196                                (unsigned long long)bh->b_blocknr, bh->b_state);
197                         bh = bh->b_this_page;
198                 } while (bh != head);
199         }
200 }
201
202 /**
203  * nilfs_copy_page -- copy the page with buffers
204  * @dst: destination page
205  * @src: source page
206  * @copy_dirty: flag whether to copy dirty states on the page's buffer heads.
207  *
208  * This function is for both data pages and btnode pages.  The dirty flag
209  * should be treated by caller.  The page must not be under i/o.
210  * Both src and dst page must be locked
211  */
212 static void nilfs_copy_page(struct page *dst, struct page *src, int copy_dirty)
213 {
214         struct buffer_head *dbh, *dbufs, *sbh, *sbufs;
215         unsigned long mask = NILFS_BUFFER_INHERENT_BITS;
216
217         BUG_ON(PageWriteback(dst));
218
219         sbh = sbufs = page_buffers(src);
220         if (!page_has_buffers(dst))
221                 create_empty_buffers(dst, sbh->b_size, 0);
222
223         if (copy_dirty)
224                 mask |= (1UL << BH_Dirty);
225
226         dbh = dbufs = page_buffers(dst);
227         do {
228                 lock_buffer(sbh);
229                 lock_buffer(dbh);
230                 dbh->b_state = sbh->b_state & mask;
231                 dbh->b_blocknr = sbh->b_blocknr;
232                 dbh->b_bdev = sbh->b_bdev;
233                 sbh = sbh->b_this_page;
234                 dbh = dbh->b_this_page;
235         } while (dbh != dbufs);
236
237         copy_highpage(dst, src);
238
239         if (PageUptodate(src) && !PageUptodate(dst))
240                 SetPageUptodate(dst);
241         else if (!PageUptodate(src) && PageUptodate(dst))
242                 ClearPageUptodate(dst);
243         if (PageMappedToDisk(src) && !PageMappedToDisk(dst))
244                 SetPageMappedToDisk(dst);
245         else if (!PageMappedToDisk(src) && PageMappedToDisk(dst))
246                 ClearPageMappedToDisk(dst);
247
248         do {
249                 unlock_buffer(sbh);
250                 unlock_buffer(dbh);
251                 sbh = sbh->b_this_page;
252                 dbh = dbh->b_this_page;
253         } while (dbh != dbufs);
254 }
255
256 int nilfs_copy_dirty_pages(struct address_space *dmap,
257                            struct address_space *smap)
258 {
259         struct pagevec pvec;
260         unsigned int i;
261         pgoff_t index = 0;
262         int err = 0;
263
264         pagevec_init(&pvec, 0);
265 repeat:
266         if (!pagevec_lookup_tag(&pvec, smap, &index, PAGECACHE_TAG_DIRTY,
267                                 PAGEVEC_SIZE))
268                 return 0;
269
270         for (i = 0; i < pagevec_count(&pvec); i++) {
271                 struct page *page = pvec.pages[i], *dpage;
272
273                 lock_page(page);
274                 if (unlikely(!PageDirty(page)))
275                         NILFS_PAGE_BUG(page, "inconsistent dirty state");
276
277                 dpage = grab_cache_page(dmap, page->index);
278                 if (unlikely(!dpage)) {
279                         /* No empty page is added to the page cache */
280                         err = -ENOMEM;
281                         unlock_page(page);
282                         break;
283                 }
284                 if (unlikely(!page_has_buffers(page)))
285                         NILFS_PAGE_BUG(page,
286                                        "found empty page in dat page cache");
287
288                 nilfs_copy_page(dpage, page, 1);
289                 __set_page_dirty_nobuffers(dpage);
290
291                 unlock_page(dpage);
292                 page_cache_release(dpage);
293                 unlock_page(page);
294         }
295         pagevec_release(&pvec);
296         cond_resched();
297
298         if (likely(!err))
299                 goto repeat;
300         return err;
301 }
302
303 /**
304  * nilfs_copy_back_pages -- copy back pages to original cache from shadow cache
305  * @dmap: destination page cache
306  * @smap: source page cache
307  *
308  * No pages must no be added to the cache during this process.
309  * This must be ensured by the caller.
310  */
311 void nilfs_copy_back_pages(struct address_space *dmap,
312                            struct address_space *smap)
313 {
314         struct pagevec pvec;
315         unsigned int i, n;
316         pgoff_t index = 0;
317         int err;
318
319         pagevec_init(&pvec, 0);
320 repeat:
321         n = pagevec_lookup(&pvec, smap, index, PAGEVEC_SIZE);
322         if (!n)
323                 return;
324         index = pvec.pages[n - 1]->index + 1;
325
326         for (i = 0; i < pagevec_count(&pvec); i++) {
327                 struct page *page = pvec.pages[i], *dpage;
328                 pgoff_t offset = page->index;
329
330                 lock_page(page);
331                 dpage = find_lock_page(dmap, offset);
332                 if (dpage) {
333                         /* override existing page on the destination cache */
334                         WARN_ON(PageDirty(dpage));
335                         nilfs_copy_page(dpage, page, 0);
336                         unlock_page(dpage);
337                         page_cache_release(dpage);
338                 } else {
339                         struct page *page2;
340
341                         /* move the page to the destination cache */
342                         spin_lock_irq(&smap->tree_lock);
343                         page2 = radix_tree_delete(&smap->page_tree, offset);
344                         WARN_ON(page2 != page);
345
346                         smap->nrpages--;
347                         spin_unlock_irq(&smap->tree_lock);
348
349                         spin_lock_irq(&dmap->tree_lock);
350                         err = radix_tree_insert(&dmap->page_tree, offset, page);
351                         if (unlikely(err < 0)) {
352                                 WARN_ON(err == -EEXIST);
353                                 page->mapping = NULL;
354                                 page_cache_release(page); /* for cache */
355                         } else {
356                                 page->mapping = dmap;
357                                 dmap->nrpages++;
358                                 if (PageDirty(page))
359                                         radix_tree_tag_set(&dmap->page_tree,
360                                                            offset,
361                                                            PAGECACHE_TAG_DIRTY);
362                         }
363                         spin_unlock_irq(&dmap->tree_lock);
364                 }
365                 unlock_page(page);
366         }
367         pagevec_release(&pvec);
368         cond_resched();
369
370         goto repeat;
371 }
372
373 /**
374  * nilfs_clear_dirty_pages - discard dirty pages in address space
375  * @mapping: address space with dirty pages for discarding
376  * @silent: suppress [true] or print [false] warning messages
377  */
378 void nilfs_clear_dirty_pages(struct address_space *mapping, bool silent)
379 {
380         struct pagevec pvec;
381         unsigned int i;
382         pgoff_t index = 0;
383
384         pagevec_init(&pvec, 0);
385
386         while (pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY,
387                                   PAGEVEC_SIZE)) {
388                 for (i = 0; i < pagevec_count(&pvec); i++) {
389                         struct page *page = pvec.pages[i];
390
391                         lock_page(page);
392                         nilfs_clear_dirty_page(page, silent);
393                         unlock_page(page);
394                 }
395                 pagevec_release(&pvec);
396                 cond_resched();
397         }
398 }
399
400 /**
401  * nilfs_clear_dirty_page - discard dirty page
402  * @page: dirty page that will be discarded
403  * @silent: suppress [true] or print [false] warning messages
404  */
405 void nilfs_clear_dirty_page(struct page *page, bool silent)
406 {
407         struct inode *inode = page->mapping->host;
408         struct super_block *sb = inode->i_sb;
409
410         BUG_ON(!PageLocked(page));
411
412         if (!silent) {
413                 nilfs_warning(sb, __func__,
414                                 "discard page: offset %lld, ino %lu",
415                                 page_offset(page), inode->i_ino);
416         }
417
418         ClearPageUptodate(page);
419         ClearPageMappedToDisk(page);
420
421         if (page_has_buffers(page)) {
422                 struct buffer_head *bh, *head;
423
424                 bh = head = page_buffers(page);
425                 do {
426                         lock_buffer(bh);
427                         if (!silent) {
428                                 nilfs_warning(sb, __func__,
429                                         "discard block %llu, size %zu",
430                                         (u64)bh->b_blocknr, bh->b_size);
431                         }
432                         clear_buffer_dirty(bh);
433                         clear_buffer_nilfs_volatile(bh);
434                         clear_buffer_nilfs_checked(bh);
435                         clear_buffer_nilfs_redirected(bh);
436                         clear_buffer_uptodate(bh);
437                         clear_buffer_mapped(bh);
438                         unlock_buffer(bh);
439                 } while (bh = bh->b_this_page, bh != head);
440         }
441
442         __nilfs_clear_page_dirty(page);
443 }
444
445 unsigned nilfs_page_count_clean_buffers(struct page *page,
446                                         unsigned from, unsigned to)
447 {
448         unsigned block_start, block_end;
449         struct buffer_head *bh, *head;
450         unsigned nc = 0;
451
452         for (bh = head = page_buffers(page), block_start = 0;
453              bh != head || !block_start;
454              block_start = block_end, bh = bh->b_this_page) {
455                 block_end = block_start + bh->b_size;
456                 if (block_end > from && block_start < to && !buffer_dirty(bh))
457                         nc++;
458         }
459         return nc;
460 }
461
462 void nilfs_mapping_init(struct address_space *mapping, struct inode *inode,
463                         struct backing_dev_info *bdi)
464 {
465         mapping->host = inode;
466         mapping->flags = 0;
467         mapping_set_gfp_mask(mapping, GFP_NOFS);
468         mapping->private_data = NULL;
469         mapping->backing_dev_info = bdi;
470         mapping->a_ops = &empty_aops;
471 }
472
473 /*
474  * NILFS2 needs clear_page_dirty() in the following two cases:
475  *
476  * 1) For B-tree node pages and data pages of the dat/gcdat, NILFS2 clears
477  *    page dirty flags when it copies back pages from the shadow cache
478  *    (gcdat->{i_mapping,i_btnode_cache}) to its original cache
479  *    (dat->{i_mapping,i_btnode_cache}).
480  *
481  * 2) Some B-tree operations like insertion or deletion may dispose buffers
482  *    in dirty state, and this needs to cancel the dirty state of their pages.
483  */
484 int __nilfs_clear_page_dirty(struct page *page)
485 {
486         struct address_space *mapping = page->mapping;
487
488         if (mapping) {
489                 spin_lock_irq(&mapping->tree_lock);
490                 if (test_bit(PG_dirty, &page->flags)) {
491                         radix_tree_tag_clear(&mapping->page_tree,
492                                              page_index(page),
493                                              PAGECACHE_TAG_DIRTY);
494                         spin_unlock_irq(&mapping->tree_lock);
495                         return clear_page_dirty_for_io(page);
496                 }
497                 spin_unlock_irq(&mapping->tree_lock);
498                 return 0;
499         }
500         return TestClearPageDirty(page);
501 }
502
503 /**
504  * nilfs_find_uncommitted_extent - find extent of uncommitted data
505  * @inode: inode
506  * @start_blk: start block offset (in)
507  * @blkoff: start offset of the found extent (out)
508  *
509  * This function searches an extent of buffers marked "delayed" which
510  * starts from a block offset equal to or larger than @start_blk.  If
511  * such an extent was found, this will store the start offset in
512  * @blkoff and return its length in blocks.  Otherwise, zero is
513  * returned.
514  */
515 unsigned long nilfs_find_uncommitted_extent(struct inode *inode,
516                                             sector_t start_blk,
517                                             sector_t *blkoff)
518 {
519         unsigned int i;
520         pgoff_t index;
521         unsigned int nblocks_in_page;
522         unsigned long length = 0;
523         sector_t b;
524         struct pagevec pvec;
525         struct page *page;
526
527         if (inode->i_mapping->nrpages == 0)
528                 return 0;
529
530         index = start_blk >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
531         nblocks_in_page = 1U << (PAGE_CACHE_SHIFT - inode->i_blkbits);
532
533         pagevec_init(&pvec, 0);
534
535 repeat:
536         pvec.nr = find_get_pages_contig(inode->i_mapping, index, PAGEVEC_SIZE,
537                                         pvec.pages);
538         if (pvec.nr == 0)
539                 return length;
540
541         if (length > 0 && pvec.pages[0]->index > index)
542                 goto out;
543
544         b = pvec.pages[0]->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
545         i = 0;
546         do {
547                 page = pvec.pages[i];
548
549                 lock_page(page);
550                 if (page_has_buffers(page)) {
551                         struct buffer_head *bh, *head;
552
553                         bh = head = page_buffers(page);
554                         do {
555                                 if (b < start_blk)
556                                         continue;
557                                 if (buffer_delay(bh)) {
558                                         if (length == 0)
559                                                 *blkoff = b;
560                                         length++;
561                                 } else if (length > 0) {
562                                         goto out_locked;
563                                 }
564                         } while (++b, bh = bh->b_this_page, bh != head);
565                 } else {
566                         if (length > 0)
567                                 goto out_locked;
568
569                         b += nblocks_in_page;
570                 }
571                 unlock_page(page);
572
573         } while (++i < pagevec_count(&pvec));
574
575         index = page->index + 1;
576         pagevec_release(&pvec);
577         cond_resched();
578         goto repeat;
579
580 out_locked:
581         unlock_page(page);
582 out:
583         pagevec_release(&pvec);
584         return length;
585 }