~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nilfs2/page.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp