2 * page.c - buffer/page management specific to NILFS
4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
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.
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.
16 * Written by Ryusuke Konishi and Seiji Kihara.
19 #include <linux/pagemap.h>
20 #include <linux/writeback.h>
21 #include <linux/swap.h>
22 #include <linux/bitops.h>
23 #include <linux/page-flags.h>
24 #include <linux/list.h>
25 #include <linux/highmem.h>
26 #include <linux/pagevec.h>
27 #include <linux/gfp.h>
33 #define NILFS_BUFFER_INHERENT_BITS \
34 ((1UL << BH_Uptodate) | (1UL << BH_Mapped) | (1UL << BH_NILFS_Node) | \
35 (1UL << BH_NILFS_Volatile) | (1UL << BH_NILFS_Checked))
37 static struct buffer_head
*
38 __nilfs_get_page_block(struct page
*page
, unsigned long block
, pgoff_t index
,
39 int blkbits
, unsigned long b_state
)
42 unsigned long first_block
;
43 struct buffer_head
*bh
;
45 if (!page_has_buffers(page
))
46 create_empty_buffers(page
, 1 << blkbits
, b_state
);
48 first_block
= (unsigned long)index
<< (PAGE_SHIFT
- blkbits
);
49 bh
= nilfs_page_get_nth_block(page
, block
- first_block
);
56 struct buffer_head
*nilfs_grab_buffer(struct inode
*inode
,
57 struct address_space
*mapping
,
59 unsigned long b_state
)
61 int blkbits
= inode
->i_blkbits
;
62 pgoff_t index
= blkoff
>> (PAGE_SHIFT
- blkbits
);
64 struct buffer_head
*bh
;
66 page
= grab_cache_page(mapping
, index
);
70 bh
= __nilfs_get_page_block(page
, blkoff
, index
, blkbits
, b_state
);
80 * nilfs_forget_buffer - discard dirty state
81 * @inode: owner inode of the buffer
82 * @bh: buffer head of the buffer to be discarded
84 void nilfs_forget_buffer(struct buffer_head
*bh
)
86 struct page
*page
= bh
->b_page
;
87 const unsigned long clear_bits
=
88 (1 << BH_Uptodate
| 1 << BH_Dirty
| 1 << BH_Mapped
|
89 1 << BH_Async_Write
| 1 << BH_NILFS_Volatile
|
90 1 << BH_NILFS_Checked
| 1 << BH_NILFS_Redirected
);
93 set_mask_bits(&bh
->b_state
, clear_bits
, 0);
94 if (nilfs_page_buffers_clean(page
))
95 __nilfs_clear_page_dirty(page
);
98 ClearPageUptodate(page
);
99 ClearPageMappedToDisk(page
);
105 * nilfs_copy_buffer -- copy buffer data and flags
106 * @dbh: destination buffer
107 * @sbh: source buffer
109 void nilfs_copy_buffer(struct buffer_head
*dbh
, struct buffer_head
*sbh
)
111 void *kaddr0
, *kaddr1
;
113 struct page
*spage
= sbh
->b_page
, *dpage
= dbh
->b_page
;
114 struct buffer_head
*bh
;
116 kaddr0
= kmap_atomic(spage
);
117 kaddr1
= kmap_atomic(dpage
);
118 memcpy(kaddr1
+ bh_offset(dbh
), kaddr0
+ bh_offset(sbh
), sbh
->b_size
);
119 kunmap_atomic(kaddr1
);
120 kunmap_atomic(kaddr0
);
122 dbh
->b_state
= sbh
->b_state
& NILFS_BUFFER_INHERENT_BITS
;
123 dbh
->b_blocknr
= sbh
->b_blocknr
;
124 dbh
->b_bdev
= sbh
->b_bdev
;
127 bits
= sbh
->b_state
& ((1UL << BH_Uptodate
) | (1UL << BH_Mapped
));
128 while ((bh
= bh
->b_this_page
) != dbh
) {
133 if (bits
& (1UL << BH_Uptodate
))
134 SetPageUptodate(dpage
);
136 ClearPageUptodate(dpage
);
137 if (bits
& (1UL << BH_Mapped
))
138 SetPageMappedToDisk(dpage
);
140 ClearPageMappedToDisk(dpage
);
144 * nilfs_page_buffers_clean - check if a page has dirty buffers or not.
145 * @page: page to be checked
147 * nilfs_page_buffers_clean() returns zero if the page has dirty buffers.
148 * Otherwise, it returns non-zero value.
150 int nilfs_page_buffers_clean(struct page
*page
)
152 struct buffer_head
*bh
, *head
;
154 bh
= head
= page_buffers(page
);
156 if (buffer_dirty(bh
))
158 bh
= bh
->b_this_page
;
159 } while (bh
!= head
);
163 void nilfs_page_bug(struct page
*page
)
165 struct address_space
*m
;
168 if (unlikely(!page
)) {
169 printk(KERN_CRIT
"NILFS_PAGE_BUG(NULL)\n");
174 ino
= m
? m
->host
->i_ino
: 0;
176 printk(KERN_CRIT
"NILFS_PAGE_BUG(%p): cnt=%d index#=%llu flags=0x%lx "
177 "mapping=%p ino=%lu\n",
178 page
, page_ref_count(page
),
179 (unsigned long long)page
->index
, page
->flags
, m
, ino
);
181 if (page_has_buffers(page
)) {
182 struct buffer_head
*bh
, *head
;
185 bh
= head
= page_buffers(page
);
188 " BH[%d] %p: cnt=%d block#=%llu state=0x%lx\n",
189 i
++, bh
, atomic_read(&bh
->b_count
),
190 (unsigned long long)bh
->b_blocknr
, bh
->b_state
);
191 bh
= bh
->b_this_page
;
192 } while (bh
!= head
);
197 * nilfs_copy_page -- copy the page with buffers
198 * @dst: destination page
200 * @copy_dirty: flag whether to copy dirty states on the page's buffer heads.
202 * This function is for both data pages and btnode pages. The dirty flag
203 * should be treated by caller. The page must not be under i/o.
204 * Both src and dst page must be locked
206 static void nilfs_copy_page(struct page
*dst
, struct page
*src
, int copy_dirty
)
208 struct buffer_head
*dbh
, *dbufs
, *sbh
, *sbufs
;
209 unsigned long mask
= NILFS_BUFFER_INHERENT_BITS
;
211 BUG_ON(PageWriteback(dst
));
213 sbh
= sbufs
= page_buffers(src
);
214 if (!page_has_buffers(dst
))
215 create_empty_buffers(dst
, sbh
->b_size
, 0);
218 mask
|= (1UL << BH_Dirty
);
220 dbh
= dbufs
= page_buffers(dst
);
224 dbh
->b_state
= sbh
->b_state
& mask
;
225 dbh
->b_blocknr
= sbh
->b_blocknr
;
226 dbh
->b_bdev
= sbh
->b_bdev
;
227 sbh
= sbh
->b_this_page
;
228 dbh
= dbh
->b_this_page
;
229 } while (dbh
!= dbufs
);
231 copy_highpage(dst
, src
);
233 if (PageUptodate(src
) && !PageUptodate(dst
))
234 SetPageUptodate(dst
);
235 else if (!PageUptodate(src
) && PageUptodate(dst
))
236 ClearPageUptodate(dst
);
237 if (PageMappedToDisk(src
) && !PageMappedToDisk(dst
))
238 SetPageMappedToDisk(dst
);
239 else if (!PageMappedToDisk(src
) && PageMappedToDisk(dst
))
240 ClearPageMappedToDisk(dst
);
245 sbh
= sbh
->b_this_page
;
246 dbh
= dbh
->b_this_page
;
247 } while (dbh
!= dbufs
);
250 int nilfs_copy_dirty_pages(struct address_space
*dmap
,
251 struct address_space
*smap
)
258 pagevec_init(&pvec
, 0);
260 if (!pagevec_lookup_tag(&pvec
, smap
, &index
, PAGECACHE_TAG_DIRTY
,
264 for (i
= 0; i
< pagevec_count(&pvec
); i
++) {
265 struct page
*page
= pvec
.pages
[i
], *dpage
;
268 if (unlikely(!PageDirty(page
)))
269 NILFS_PAGE_BUG(page
, "inconsistent dirty state");
271 dpage
= grab_cache_page(dmap
, page
->index
);
272 if (unlikely(!dpage
)) {
273 /* No empty page is added to the page cache */
278 if (unlikely(!page_has_buffers(page
)))
280 "found empty page in dat page cache");
282 nilfs_copy_page(dpage
, page
, 1);
283 __set_page_dirty_nobuffers(dpage
);
289 pagevec_release(&pvec
);
298 * nilfs_copy_back_pages -- copy back pages to original cache from shadow cache
299 * @dmap: destination page cache
300 * @smap: source page cache
302 * No pages must no be added to the cache during this process.
303 * This must be ensured by the caller.
305 void nilfs_copy_back_pages(struct address_space
*dmap
,
306 struct address_space
*smap
)
313 pagevec_init(&pvec
, 0);
315 n
= pagevec_lookup(&pvec
, smap
, index
, PAGEVEC_SIZE
);
318 index
= pvec
.pages
[n
- 1]->index
+ 1;
320 for (i
= 0; i
< pagevec_count(&pvec
); i
++) {
321 struct page
*page
= pvec
.pages
[i
], *dpage
;
322 pgoff_t offset
= page
->index
;
325 dpage
= find_lock_page(dmap
, offset
);
327 /* override existing page on the destination cache */
328 WARN_ON(PageDirty(dpage
));
329 nilfs_copy_page(dpage
, page
, 0);
335 /* move the page to the destination cache */
336 spin_lock_irq(&smap
->tree_lock
);
337 page2
= radix_tree_delete(&smap
->page_tree
, offset
);
338 WARN_ON(page2
!= page
);
341 spin_unlock_irq(&smap
->tree_lock
);
343 spin_lock_irq(&dmap
->tree_lock
);
344 err
= radix_tree_insert(&dmap
->page_tree
, offset
, page
);
345 if (unlikely(err
< 0)) {
346 WARN_ON(err
== -EEXIST
);
347 page
->mapping
= NULL
;
348 put_page(page
); /* for cache */
350 page
->mapping
= dmap
;
353 radix_tree_tag_set(&dmap
->page_tree
,
355 PAGECACHE_TAG_DIRTY
);
357 spin_unlock_irq(&dmap
->tree_lock
);
361 pagevec_release(&pvec
);
368 * nilfs_clear_dirty_pages - discard dirty pages in address space
369 * @mapping: address space with dirty pages for discarding
370 * @silent: suppress [true] or print [false] warning messages
372 void nilfs_clear_dirty_pages(struct address_space
*mapping
, bool silent
)
378 pagevec_init(&pvec
, 0);
380 while (pagevec_lookup_tag(&pvec
, mapping
, &index
, PAGECACHE_TAG_DIRTY
,
382 for (i
= 0; i
< pagevec_count(&pvec
); i
++) {
383 struct page
*page
= pvec
.pages
[i
];
386 nilfs_clear_dirty_page(page
, silent
);
389 pagevec_release(&pvec
);
395 * nilfs_clear_dirty_page - discard dirty page
396 * @page: dirty page that will be discarded
397 * @silent: suppress [true] or print [false] warning messages
399 void nilfs_clear_dirty_page(struct page
*page
, bool silent
)
401 struct inode
*inode
= page
->mapping
->host
;
402 struct super_block
*sb
= inode
->i_sb
;
404 BUG_ON(!PageLocked(page
));
407 nilfs_warning(sb
, __func__
,
408 "discard page: offset %lld, ino %lu",
409 page_offset(page
), inode
->i_ino
);
412 ClearPageUptodate(page
);
413 ClearPageMappedToDisk(page
);
415 if (page_has_buffers(page
)) {
416 struct buffer_head
*bh
, *head
;
417 const unsigned long clear_bits
=
418 (1 << BH_Uptodate
| 1 << BH_Dirty
| 1 << BH_Mapped
|
419 1 << BH_Async_Write
| 1 << BH_NILFS_Volatile
|
420 1 << BH_NILFS_Checked
| 1 << BH_NILFS_Redirected
);
422 bh
= head
= page_buffers(page
);
426 nilfs_warning(sb
, __func__
,
427 "discard block %llu, size %zu",
428 (u64
)bh
->b_blocknr
, bh
->b_size
);
430 set_mask_bits(&bh
->b_state
, clear_bits
, 0);
432 } while (bh
= bh
->b_this_page
, bh
!= head
);
435 __nilfs_clear_page_dirty(page
);
438 unsigned int nilfs_page_count_clean_buffers(struct page
*page
,
439 unsigned int from
, unsigned int to
)
441 unsigned int block_start
, block_end
;
442 struct buffer_head
*bh
, *head
;
445 for (bh
= head
= page_buffers(page
), block_start
= 0;
446 bh
!= head
|| !block_start
;
447 block_start
= block_end
, bh
= bh
->b_this_page
) {
448 block_end
= block_start
+ bh
->b_size
;
449 if (block_end
> from
&& block_start
< to
&& !buffer_dirty(bh
))
455 void nilfs_mapping_init(struct address_space
*mapping
, struct inode
*inode
)
457 mapping
->host
= inode
;
459 mapping_set_gfp_mask(mapping
, GFP_NOFS
);
460 mapping
->private_data
= NULL
;
461 mapping
->a_ops
= &empty_aops
;
465 * NILFS2 needs clear_page_dirty() in the following two cases:
467 * 1) For B-tree node pages and data pages of the dat/gcdat, NILFS2 clears
468 * page dirty flags when it copies back pages from the shadow cache
469 * (gcdat->{i_mapping,i_btnode_cache}) to its original cache
470 * (dat->{i_mapping,i_btnode_cache}).
472 * 2) Some B-tree operations like insertion or deletion may dispose buffers
473 * in dirty state, and this needs to cancel the dirty state of their pages.
475 int __nilfs_clear_page_dirty(struct page
*page
)
477 struct address_space
*mapping
= page
->mapping
;
480 spin_lock_irq(&mapping
->tree_lock
);
481 if (test_bit(PG_dirty
, &page
->flags
)) {
482 radix_tree_tag_clear(&mapping
->page_tree
,
484 PAGECACHE_TAG_DIRTY
);
485 spin_unlock_irq(&mapping
->tree_lock
);
486 return clear_page_dirty_for_io(page
);
488 spin_unlock_irq(&mapping
->tree_lock
);
491 return TestClearPageDirty(page
);
495 * nilfs_find_uncommitted_extent - find extent of uncommitted data
497 * @start_blk: start block offset (in)
498 * @blkoff: start offset of the found extent (out)
500 * This function searches an extent of buffers marked "delayed" which
501 * starts from a block offset equal to or larger than @start_blk. If
502 * such an extent was found, this will store the start offset in
503 * @blkoff and return its length in blocks. Otherwise, zero is
506 unsigned long nilfs_find_uncommitted_extent(struct inode
*inode
,
512 unsigned int nblocks_in_page
;
513 unsigned long length
= 0;
518 if (inode
->i_mapping
->nrpages
== 0)
521 index
= start_blk
>> (PAGE_SHIFT
- inode
->i_blkbits
);
522 nblocks_in_page
= 1U << (PAGE_SHIFT
- inode
->i_blkbits
);
524 pagevec_init(&pvec
, 0);
527 pvec
.nr
= find_get_pages_contig(inode
->i_mapping
, index
, PAGEVEC_SIZE
,
532 if (length
> 0 && pvec
.pages
[0]->index
> index
)
535 b
= pvec
.pages
[0]->index
<< (PAGE_SHIFT
- inode
->i_blkbits
);
538 page
= pvec
.pages
[i
];
541 if (page_has_buffers(page
)) {
542 struct buffer_head
*bh
, *head
;
544 bh
= head
= page_buffers(page
);
548 if (buffer_delay(bh
)) {
552 } else if (length
> 0) {
555 } while (++b
, bh
= bh
->b_this_page
, bh
!= head
);
560 b
+= nblocks_in_page
;
564 } while (++i
< pagevec_count(&pvec
));
566 index
= page
->index
+ 1;
567 pagevec_release(&pvec
);
574 pagevec_release(&pvec
);