Merge branch 'for-2.6.39/stack-plug' into for-2.6.39/core
[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_Allocated) | \
41          (1UL << BH_NILFS_Checked))
42
43 static struct buffer_head *
44 __nilfs_get_page_block(struct page *page, unsigned long block, pgoff_t index,
45                        int blkbits, unsigned long b_state)
46
47 {
48         unsigned long first_block;
49         struct buffer_head *bh;
50
51         if (!page_has_buffers(page))
52                 create_empty_buffers(page, 1 << blkbits, b_state);
53
54         first_block = (unsigned long)index << (PAGE_CACHE_SHIFT - blkbits);
55         bh = nilfs_page_get_nth_block(page, block - first_block);
56
57         touch_buffer(bh);
58         wait_on_buffer(bh);
59         return bh;
60 }
61
62 /*
63  * Since the page cache of B-tree node pages or data page cache of pseudo
64  * inodes does not have a valid mapping->host pointer, calling
65  * mark_buffer_dirty() for their buffers causes a NULL pointer dereference;
66  * it calls __mark_inode_dirty(NULL) through __set_page_dirty().
67  * To avoid this problem, the old style mark_buffer_dirty() is used instead.
68  */
69 void nilfs_mark_buffer_dirty(struct buffer_head *bh)
70 {
71         if (!buffer_dirty(bh) && !test_set_buffer_dirty(bh))
72                 __set_page_dirty_nobuffers(bh->b_page);
73 }
74
75 struct buffer_head *nilfs_grab_buffer(struct inode *inode,
76                                       struct address_space *mapping,
77                                       unsigned long blkoff,
78                                       unsigned long b_state)
79 {
80         int blkbits = inode->i_blkbits;
81         pgoff_t index = blkoff >> (PAGE_CACHE_SHIFT - blkbits);
82         struct page *page;
83         struct buffer_head *bh;
84
85         page = grab_cache_page(mapping, index);
86         if (unlikely(!page))
87                 return NULL;
88
89         bh = __nilfs_get_page_block(page, blkoff, index, blkbits, b_state);
90         if (unlikely(!bh)) {
91                 unlock_page(page);
92                 page_cache_release(page);
93                 return NULL;
94         }
95         return bh;
96 }
97
98 /**
99  * nilfs_forget_buffer - discard dirty state
100  * @inode: owner inode of the buffer
101  * @bh: buffer head of the buffer to be discarded
102  */
103 void nilfs_forget_buffer(struct buffer_head *bh)
104 {
105         struct page *page = bh->b_page;
106
107         lock_buffer(bh);
108         clear_buffer_nilfs_volatile(bh);
109         clear_buffer_nilfs_checked(bh);
110         clear_buffer_nilfs_redirected(bh);
111         clear_buffer_dirty(bh);
112         if (nilfs_page_buffers_clean(page))
113                 __nilfs_clear_page_dirty(page);
114
115         clear_buffer_uptodate(bh);
116         clear_buffer_mapped(bh);
117         bh->b_blocknr = -1;
118         ClearPageUptodate(page);
119         ClearPageMappedToDisk(page);
120         unlock_buffer(bh);
121         brelse(bh);
122 }
123
124 /**
125  * nilfs_copy_buffer -- copy buffer data and flags
126  * @dbh: destination buffer
127  * @sbh: source buffer
128  */
129 void nilfs_copy_buffer(struct buffer_head *dbh, struct buffer_head *sbh)
130 {
131         void *kaddr0, *kaddr1;
132         unsigned long bits;
133         struct page *spage = sbh->b_page, *dpage = dbh->b_page;
134         struct buffer_head *bh;
135
136         kaddr0 = kmap_atomic(spage, KM_USER0);
137         kaddr1 = kmap_atomic(dpage, KM_USER1);
138         memcpy(kaddr1 + bh_offset(dbh), kaddr0 + bh_offset(sbh), sbh->b_size);
139         kunmap_atomic(kaddr1, KM_USER1);
140         kunmap_atomic(kaddr0, KM_USER0);
141
142         dbh->b_state = sbh->b_state & NILFS_BUFFER_INHERENT_BITS;
143         dbh->b_blocknr = sbh->b_blocknr;
144         dbh->b_bdev = sbh->b_bdev;
145
146         bh = dbh;
147         bits = sbh->b_state & ((1UL << BH_Uptodate) | (1UL << BH_Mapped));
148         while ((bh = bh->b_this_page) != dbh) {
149                 lock_buffer(bh);
150                 bits &= bh->b_state;
151                 unlock_buffer(bh);
152         }
153         if (bits & (1UL << BH_Uptodate))
154                 SetPageUptodate(dpage);
155         else
156                 ClearPageUptodate(dpage);
157         if (bits & (1UL << BH_Mapped))
158                 SetPageMappedToDisk(dpage);
159         else
160                 ClearPageMappedToDisk(dpage);
161 }
162
163 /**
164  * nilfs_page_buffers_clean - check if a page has dirty buffers or not.
165  * @page: page to be checked
166  *
167  * nilfs_page_buffers_clean() returns zero if the page has dirty buffers.
168  * Otherwise, it returns non-zero value.
169  */
170 int nilfs_page_buffers_clean(struct page *page)
171 {
172         struct buffer_head *bh, *head;
173
174         bh = head = page_buffers(page);
175         do {
176                 if (buffer_dirty(bh))
177                         return 0;
178                 bh = bh->b_this_page;
179         } while (bh != head);
180         return 1;
181 }
182
183 void nilfs_page_bug(struct page *page)
184 {
185         struct address_space *m;
186         unsigned long ino = 0;
187
188         if (unlikely(!page)) {
189                 printk(KERN_CRIT "NILFS_PAGE_BUG(NULL)\n");
190                 return;
191         }
192
193         m = page->mapping;
194         if (m) {
195                 struct inode *inode = NILFS_AS_I(m);
196                 if (inode != NULL)
197                         ino = inode->i_ino;
198         }
199         printk(KERN_CRIT "NILFS_PAGE_BUG(%p): cnt=%d index#=%llu flags=0x%lx "
200                "mapping=%p ino=%lu\n",
201                page, atomic_read(&page->_count),
202                (unsigned long long)page->index, page->flags, m, ino);
203
204         if (page_has_buffers(page)) {
205                 struct buffer_head *bh, *head;
206                 int i = 0;
207
208                 bh = head = page_buffers(page);
209                 do {
210                         printk(KERN_CRIT
211                                " BH[%d] %p: cnt=%d block#=%llu state=0x%lx\n",
212                                i++, bh, atomic_read(&bh->b_count),
213                                (unsigned long long)bh->b_blocknr, bh->b_state);
214                         bh = bh->b_this_page;
215                 } while (bh != head);
216         }
217 }
218
219 /**
220  * nilfs_alloc_private_page - allocate a private page with buffer heads
221  *
222  * Return Value: On success, a pointer to the allocated page is returned.
223  * On error, NULL is returned.
224  */
225 struct page *nilfs_alloc_private_page(struct block_device *bdev, int size,
226                                       unsigned long state)
227 {
228         struct buffer_head *bh, *head, *tail;
229         struct page *page;
230
231         page = alloc_page(GFP_NOFS); /* page_count of the returned page is 1 */
232         if (unlikely(!page))
233                 return NULL;
234
235         lock_page(page);
236         head = alloc_page_buffers(page, size, 0);
237         if (unlikely(!head)) {
238                 unlock_page(page);
239                 __free_page(page);
240                 return NULL;
241         }
242
243         bh = head;
244         do {
245                 bh->b_state = (1UL << BH_NILFS_Allocated) | state;
246                 tail = bh;
247                 bh->b_bdev = bdev;
248                 bh = bh->b_this_page;
249         } while (bh);
250
251         tail->b_this_page = head;
252         attach_page_buffers(page, head);
253
254         return page;
255 }
256
257 void nilfs_free_private_page(struct page *page)
258 {
259         BUG_ON(!PageLocked(page));
260         BUG_ON(page->mapping);
261
262         if (page_has_buffers(page) && !try_to_free_buffers(page))
263                 NILFS_PAGE_BUG(page, "failed to free page");
264
265         unlock_page(page);
266         __free_page(page);
267 }
268
269 /**
270  * nilfs_copy_page -- copy the page with buffers
271  * @dst: destination page
272  * @src: source page
273  * @copy_dirty: flag whether to copy dirty states on the page's buffer heads.
274  *
275  * This function is for both data pages and btnode pages.  The dirty flag
276  * should be treated by caller.  The page must not be under i/o.
277  * Both src and dst page must be locked
278  */
279 static void nilfs_copy_page(struct page *dst, struct page *src, int copy_dirty)
280 {
281         struct buffer_head *dbh, *dbufs, *sbh, *sbufs;
282         unsigned long mask = NILFS_BUFFER_INHERENT_BITS;
283
284         BUG_ON(PageWriteback(dst));
285
286         sbh = sbufs = page_buffers(src);
287         if (!page_has_buffers(dst))
288                 create_empty_buffers(dst, sbh->b_size, 0);
289
290         if (copy_dirty)
291                 mask |= (1UL << BH_Dirty);
292
293         dbh = dbufs = page_buffers(dst);
294         do {
295                 lock_buffer(sbh);
296                 lock_buffer(dbh);
297                 dbh->b_state = sbh->b_state & mask;
298                 dbh->b_blocknr = sbh->b_blocknr;
299                 dbh->b_bdev = sbh->b_bdev;
300                 sbh = sbh->b_this_page;
301                 dbh = dbh->b_this_page;
302         } while (dbh != dbufs);
303
304         copy_highpage(dst, src);
305
306         if (PageUptodate(src) && !PageUptodate(dst))
307                 SetPageUptodate(dst);
308         else if (!PageUptodate(src) && PageUptodate(dst))
309                 ClearPageUptodate(dst);
310         if (PageMappedToDisk(src) && !PageMappedToDisk(dst))
311                 SetPageMappedToDisk(dst);
312         else if (!PageMappedToDisk(src) && PageMappedToDisk(dst))
313                 ClearPageMappedToDisk(dst);
314
315         do {
316                 unlock_buffer(sbh);
317                 unlock_buffer(dbh);
318                 sbh = sbh->b_this_page;
319                 dbh = dbh->b_this_page;
320         } while (dbh != dbufs);
321 }
322
323 int nilfs_copy_dirty_pages(struct address_space *dmap,
324                            struct address_space *smap)
325 {
326         struct pagevec pvec;
327         unsigned int i;
328         pgoff_t index = 0;
329         int err = 0;
330
331         pagevec_init(&pvec, 0);
332 repeat:
333         if (!pagevec_lookup_tag(&pvec, smap, &index, PAGECACHE_TAG_DIRTY,
334                                 PAGEVEC_SIZE))
335                 return 0;
336
337         for (i = 0; i < pagevec_count(&pvec); i++) {
338                 struct page *page = pvec.pages[i], *dpage;
339
340                 lock_page(page);
341                 if (unlikely(!PageDirty(page)))
342                         NILFS_PAGE_BUG(page, "inconsistent dirty state");
343
344                 dpage = grab_cache_page(dmap, page->index);
345                 if (unlikely(!dpage)) {
346                         /* No empty page is added to the page cache */
347                         err = -ENOMEM;
348                         unlock_page(page);
349                         break;
350                 }
351                 if (unlikely(!page_has_buffers(page)))
352                         NILFS_PAGE_BUG(page,
353                                        "found empty page in dat page cache");
354
355                 nilfs_copy_page(dpage, page, 1);
356                 __set_page_dirty_nobuffers(dpage);
357
358                 unlock_page(dpage);
359                 page_cache_release(dpage);
360                 unlock_page(page);
361         }
362         pagevec_release(&pvec);
363         cond_resched();
364
365         if (likely(!err))
366                 goto repeat;
367         return err;
368 }
369
370 /**
371  * nilfs_copy_back_pages -- copy back pages to original cache from shadow cache
372  * @dmap: destination page cache
373  * @smap: source page cache
374  *
375  * No pages must no be added to the cache during this process.
376  * This must be ensured by the caller.
377  */
378 void nilfs_copy_back_pages(struct address_space *dmap,
379                            struct address_space *smap)
380 {
381         struct pagevec pvec;
382         unsigned int i, n;
383         pgoff_t index = 0;
384         int err;
385
386         pagevec_init(&pvec, 0);
387 repeat:
388         n = pagevec_lookup(&pvec, smap, index, PAGEVEC_SIZE);
389         if (!n)
390                 return;
391         index = pvec.pages[n - 1]->index + 1;
392
393         for (i = 0; i < pagevec_count(&pvec); i++) {
394                 struct page *page = pvec.pages[i], *dpage;
395                 pgoff_t offset = page->index;
396
397                 lock_page(page);
398                 dpage = find_lock_page(dmap, offset);
399                 if (dpage) {
400                         /* override existing page on the destination cache */
401                         WARN_ON(PageDirty(dpage));
402                         nilfs_copy_page(dpage, page, 0);
403                         unlock_page(dpage);
404                         page_cache_release(dpage);
405                 } else {
406                         struct page *page2;
407
408                         /* move the page to the destination cache */
409                         spin_lock_irq(&smap->tree_lock);
410                         page2 = radix_tree_delete(&smap->page_tree, offset);
411                         WARN_ON(page2 != page);
412
413                         smap->nrpages--;
414                         spin_unlock_irq(&smap->tree_lock);
415
416                         spin_lock_irq(&dmap->tree_lock);
417                         err = radix_tree_insert(&dmap->page_tree, offset, page);
418                         if (unlikely(err < 0)) {
419                                 WARN_ON(err == -EEXIST);
420                                 page->mapping = NULL;
421                                 page_cache_release(page); /* for cache */
422                         } else {
423                                 page->mapping = dmap;
424                                 dmap->nrpages++;
425                                 if (PageDirty(page))
426                                         radix_tree_tag_set(&dmap->page_tree,
427                                                            offset,
428                                                            PAGECACHE_TAG_DIRTY);
429                         }
430                         spin_unlock_irq(&dmap->tree_lock);
431                 }
432                 unlock_page(page);
433         }
434         pagevec_release(&pvec);
435         cond_resched();
436
437         goto repeat;
438 }
439
440 void nilfs_clear_dirty_pages(struct address_space *mapping)
441 {
442         struct pagevec pvec;
443         unsigned int i;
444         pgoff_t index = 0;
445
446         pagevec_init(&pvec, 0);
447
448         while (pagevec_lookup_tag(&pvec, mapping, &index, PAGECACHE_TAG_DIRTY,
449                                   PAGEVEC_SIZE)) {
450                 for (i = 0; i < pagevec_count(&pvec); i++) {
451                         struct page *page = pvec.pages[i];
452                         struct buffer_head *bh, *head;
453
454                         lock_page(page);
455                         ClearPageUptodate(page);
456                         ClearPageMappedToDisk(page);
457                         bh = head = page_buffers(page);
458                         do {
459                                 lock_buffer(bh);
460                                 clear_buffer_dirty(bh);
461                                 clear_buffer_nilfs_volatile(bh);
462                                 clear_buffer_nilfs_checked(bh);
463                                 clear_buffer_nilfs_redirected(bh);
464                                 clear_buffer_uptodate(bh);
465                                 clear_buffer_mapped(bh);
466                                 unlock_buffer(bh);
467                                 bh = bh->b_this_page;
468                         } while (bh != head);
469
470                         __nilfs_clear_page_dirty(page);
471                         unlock_page(page);
472                 }
473                 pagevec_release(&pvec);
474                 cond_resched();
475         }
476 }
477
478 unsigned nilfs_page_count_clean_buffers(struct page *page,
479                                         unsigned from, unsigned to)
480 {
481         unsigned block_start, block_end;
482         struct buffer_head *bh, *head;
483         unsigned nc = 0;
484
485         for (bh = head = page_buffers(page), block_start = 0;
486              bh != head || !block_start;
487              block_start = block_end, bh = bh->b_this_page) {
488                 block_end = block_start + bh->b_size;
489                 if (block_end > from && block_start < to && !buffer_dirty(bh))
490                         nc++;
491         }
492         return nc;
493 }
494
495 void nilfs_mapping_init(struct address_space *mapping,
496                         struct backing_dev_info *bdi)
497 {
498         mapping->host = NULL;
499         mapping->flags = 0;
500         mapping_set_gfp_mask(mapping, GFP_NOFS);
501         mapping->assoc_mapping = NULL;
502         mapping->backing_dev_info = bdi;
503         mapping->a_ops = NULL;
504 }
505
506 /*
507  * NILFS2 needs clear_page_dirty() in the following two cases:
508  *
509  * 1) For B-tree node pages and data pages of the dat/gcdat, NILFS2 clears
510  *    page dirty flags when it copies back pages from the shadow cache
511  *    (gcdat->{i_mapping,i_btnode_cache}) to its original cache
512  *    (dat->{i_mapping,i_btnode_cache}).
513  *
514  * 2) Some B-tree operations like insertion or deletion may dispose buffers
515  *    in dirty state, and this needs to cancel the dirty state of their pages.
516  */
517 int __nilfs_clear_page_dirty(struct page *page)
518 {
519         struct address_space *mapping = page->mapping;
520
521         if (mapping) {
522                 spin_lock_irq(&mapping->tree_lock);
523                 if (test_bit(PG_dirty, &page->flags)) {
524                         radix_tree_tag_clear(&mapping->page_tree,
525                                              page_index(page),
526                                              PAGECACHE_TAG_DIRTY);
527                         spin_unlock_irq(&mapping->tree_lock);
528                         return clear_page_dirty_for_io(page);
529                 }
530                 spin_unlock_irq(&mapping->tree_lock);
531                 return 0;
532         }
533         return TestClearPageDirty(page);
534 }
535
536 /**
537  * nilfs_find_uncommitted_extent - find extent of uncommitted data
538  * @inode: inode
539  * @start_blk: start block offset (in)
540  * @blkoff: start offset of the found extent (out)
541  *
542  * This function searches an extent of buffers marked "delayed" which
543  * starts from a block offset equal to or larger than @start_blk.  If
544  * such an extent was found, this will store the start offset in
545  * @blkoff and return its length in blocks.  Otherwise, zero is
546  * returned.
547  */
548 unsigned long nilfs_find_uncommitted_extent(struct inode *inode,
549                                             sector_t start_blk,
550                                             sector_t *blkoff)
551 {
552         unsigned int i;
553         pgoff_t index;
554         unsigned int nblocks_in_page;
555         unsigned long length = 0;
556         sector_t b;
557         struct pagevec pvec;
558         struct page *page;
559
560         if (inode->i_mapping->nrpages == 0)
561                 return 0;
562
563         index = start_blk >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
564         nblocks_in_page = 1U << (PAGE_CACHE_SHIFT - inode->i_blkbits);
565
566         pagevec_init(&pvec, 0);
567
568 repeat:
569         pvec.nr = find_get_pages_contig(inode->i_mapping, index, PAGEVEC_SIZE,
570                                         pvec.pages);
571         if (pvec.nr == 0)
572                 return length;
573
574         if (length > 0 && pvec.pages[0]->index > index)
575                 goto out;
576
577         b = pvec.pages[0]->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
578         i = 0;
579         do {
580                 page = pvec.pages[i];
581
582                 lock_page(page);
583                 if (page_has_buffers(page)) {
584                         struct buffer_head *bh, *head;
585
586                         bh = head = page_buffers(page);
587                         do {
588                                 if (b < start_blk)
589                                         continue;
590                                 if (buffer_delay(bh)) {
591                                         if (length == 0)
592                                                 *blkoff = b;
593                                         length++;
594                                 } else if (length > 0) {
595                                         goto out_locked;
596                                 }
597                         } while (++b, bh = bh->b_this_page, bh != head);
598                 } else {
599                         if (length > 0)
600                                 goto out_locked;
601
602                         b += nblocks_in_page;
603                 }
604                 unlock_page(page);
605
606         } while (++i < pagevec_count(&pvec));
607
608         index = page->index + 1;
609         pagevec_release(&pvec);
610         cond_resched();
611         goto repeat;
612
613 out_locked:
614         unlock_page(page);
615 out:
616         pagevec_release(&pvec);
617         return length;
618 }