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 <[email protected]>,
  21  *            Seiji Kihara <[email protected]>.
  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 }