1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. 4 * 5 * This copyrighted material is made available to anyone wishing to use, 6 * modify, copy, or redistribute it subject to the terms and conditions 7 * of the GNU General Public License version 2. 8 */ 9 10 #include <linux/sched.h> 11 #include <linux/slab.h> 12 #include <linux/spinlock.h> 13 #include <linux/completion.h> 14 #include <linux/buffer_head.h> 15 #include <linux/pagemap.h> 16 #include <linux/pagevec.h> 17 #include <linux/mpage.h> 18 #include <linux/fs.h> 19 #include <linux/writeback.h> 20 #include <linux/swap.h> 21 #include <linux/gfs2_ondisk.h> 22 #include <linux/backing-dev.h> 23 24 #include "gfs2.h" 25 #include "incore.h" 26 #include "bmap.h" 27 #include "glock.h" 28 #include "inode.h" 29 #include "log.h" 30 #include "meta_io.h" 31 #include "quota.h" 32 #include "trans.h" 33 #include "rgrp.h" 34 #include "super.h" 35 #include "util.h" 36 #include "glops.h" 37 38 39 static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page, 40 unsigned int from, unsigned int to) 41 { 42 struct buffer_head *head = page_buffers(page); 43 unsigned int bsize = head->b_size; 44 struct buffer_head *bh; 45 unsigned int start, end; 46 47 for (bh = head, start = 0; bh != head || !start; 48 bh = bh->b_this_page, start = end) { 49 end = start + bsize; 50 if (end <= from || start >= to) 51 continue; 52 if (gfs2_is_jdata(ip)) 53 set_buffer_uptodate(bh); 54 gfs2_trans_add_bh(ip->i_gl, bh, 0); 55 } 56 } 57 58 /** 59 * gfs2_get_block_noalloc - Fills in a buffer head with details about a block 60 * @inode: The inode 61 * @lblock: The block number to look up 62 * @bh_result: The buffer head to return the result in 63 * @create: Non-zero if we may add block to the file 64 * 65 * Returns: errno 66 */ 67 68 static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock, 69 struct buffer_head *bh_result, int create) 70 { 71 int error; 72 73 error = gfs2_block_map(inode, lblock, bh_result, 0); 74 if (error) 75 return error; 76 if (!buffer_mapped(bh_result)) 77 return -EIO; 78 return 0; 79 } 80 81 static int gfs2_get_block_direct(struct inode *inode, sector_t lblock, 82 struct buffer_head *bh_result, int create) 83 { 84 return gfs2_block_map(inode, lblock, bh_result, 0); 85 } 86 87 /** 88 * gfs2_writepage_common - Common bits of writepage 89 * @page: The page to be written 90 * @wbc: The writeback control 91 * 92 * Returns: 1 if writepage is ok, otherwise an error code or zero if no error. 93 */ 94 95 static int gfs2_writepage_common(struct page *page, 96 struct writeback_control *wbc) 97 { 98 struct inode *inode = page->mapping->host; 99 struct gfs2_inode *ip = GFS2_I(inode); 100 struct gfs2_sbd *sdp = GFS2_SB(inode); 101 loff_t i_size = i_size_read(inode); 102 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT; 103 unsigned offset; 104 105 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) 106 goto out; 107 if (current->journal_info) 108 goto redirty; 109 /* Is the page fully outside i_size? (truncate in progress) */ 110 offset = i_size & (PAGE_CACHE_SIZE-1); 111 if (page->index > end_index || (page->index == end_index && !offset)) { 112 page->mapping->a_ops->invalidatepage(page, 0); 113 goto out; 114 } 115 return 1; 116 redirty: 117 redirty_page_for_writepage(wbc, page); 118 out: 119 unlock_page(page); 120 return 0; 121 } 122 123 /** 124 * gfs2_writeback_writepage - Write page for writeback mappings 125 * @page: The page 126 * @wbc: The writeback control 127 * 128 */ 129 130 static int gfs2_writeback_writepage(struct page *page, 131 struct writeback_control *wbc) 132 { 133 int ret; 134 135 ret = gfs2_writepage_common(page, wbc); 136 if (ret <= 0) 137 return ret; 138 139 ret = mpage_writepage(page, gfs2_get_block_noalloc, wbc); 140 if (ret == -EAGAIN) 141 ret = block_write_full_page(page, gfs2_get_block_noalloc, wbc); 142 return ret; 143 } 144 145 /** 146 * gfs2_ordered_writepage - Write page for ordered data files 147 * @page: The page to write 148 * @wbc: The writeback control 149 * 150 */ 151 152 static int gfs2_ordered_writepage(struct page *page, 153 struct writeback_control *wbc) 154 { 155 struct inode *inode = page->mapping->host; 156 struct gfs2_inode *ip = GFS2_I(inode); 157 int ret; 158 159 ret = gfs2_writepage_common(page, wbc); 160 if (ret <= 0) 161 return ret; 162 163 if (!page_has_buffers(page)) { 164 create_empty_buffers(page, inode->i_sb->s_blocksize, 165 (1 << BH_Dirty)|(1 << BH_Uptodate)); 166 } 167 gfs2_page_add_databufs(ip, page, 0, inode->i_sb->s_blocksize-1); 168 return block_write_full_page(page, gfs2_get_block_noalloc, wbc); 169 } 170 171 /** 172 * __gfs2_jdata_writepage - The core of jdata writepage 173 * @page: The page to write 174 * @wbc: The writeback control 175 * 176 * This is shared between writepage and writepages and implements the 177 * core of the writepage operation. If a transaction is required then 178 * PageChecked will have been set and the transaction will have 179 * already been started before this is called. 180 */ 181 182 static int __gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc) 183 { 184 struct inode *inode = page->mapping->host; 185 struct gfs2_inode *ip = GFS2_I(inode); 186 struct gfs2_sbd *sdp = GFS2_SB(inode); 187 188 if (PageChecked(page)) { 189 ClearPageChecked(page); 190 if (!page_has_buffers(page)) { 191 create_empty_buffers(page, inode->i_sb->s_blocksize, 192 (1 << BH_Dirty)|(1 << BH_Uptodate)); 193 } 194 gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1); 195 } 196 return block_write_full_page(page, gfs2_get_block_noalloc, wbc); 197 } 198 199 /** 200 * gfs2_jdata_writepage - Write complete page 201 * @page: Page to write 202 * 203 * Returns: errno 204 * 205 */ 206 207 static int gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc) 208 { 209 struct inode *inode = page->mapping->host; 210 struct gfs2_sbd *sdp = GFS2_SB(inode); 211 int ret; 212 int done_trans = 0; 213 214 if (PageChecked(page)) { 215 if (wbc->sync_mode != WB_SYNC_ALL) 216 goto out_ignore; 217 ret = gfs2_trans_begin(sdp, RES_DINODE + 1, 0); 218 if (ret) 219 goto out_ignore; 220 done_trans = 1; 221 } 222 ret = gfs2_writepage_common(page, wbc); 223 if (ret > 0) 224 ret = __gfs2_jdata_writepage(page, wbc); 225 if (done_trans) 226 gfs2_trans_end(sdp); 227 return ret; 228 229 out_ignore: 230 redirty_page_for_writepage(wbc, page); 231 unlock_page(page); 232 return 0; 233 } 234 235 /** 236 * gfs2_writeback_writepages - Write a bunch of dirty pages back to disk 237 * @mapping: The mapping to write 238 * @wbc: Write-back control 239 * 240 * For the data=writeback case we can already ignore buffer heads 241 * and write whole extents at once. This is a big reduction in the 242 * number of I/O requests we send and the bmap calls we make in this case. 243 */ 244 static int gfs2_writeback_writepages(struct address_space *mapping, 245 struct writeback_control *wbc) 246 { 247 return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc); 248 } 249 250 /** 251 * gfs2_write_jdata_pagevec - Write back a pagevec's worth of pages 252 * @mapping: The mapping 253 * @wbc: The writeback control 254 * @writepage: The writepage function to call for each page 255 * @pvec: The vector of pages 256 * @nr_pages: The number of pages to write 257 * 258 * Returns: non-zero if loop should terminate, zero otherwise 259 */ 260 261 static int gfs2_write_jdata_pagevec(struct address_space *mapping, 262 struct writeback_control *wbc, 263 struct pagevec *pvec, 264 int nr_pages, pgoff_t end) 265 { 266 struct inode *inode = mapping->host; 267 struct gfs2_sbd *sdp = GFS2_SB(inode); 268 loff_t i_size = i_size_read(inode); 269 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT; 270 unsigned offset = i_size & (PAGE_CACHE_SIZE-1); 271 unsigned nrblocks = nr_pages * (PAGE_CACHE_SIZE/inode->i_sb->s_blocksize); 272 int i; 273 int ret; 274 275 ret = gfs2_trans_begin(sdp, nrblocks, nrblocks); 276 if (ret < 0) 277 return ret; 278 279 for(i = 0; i < nr_pages; i++) { 280 struct page *page = pvec->pages[i]; 281 282 lock_page(page); 283 284 if (unlikely(page->mapping != mapping)) { 285 unlock_page(page); 286 continue; 287 } 288 289 if (!wbc->range_cyclic && page->index > end) { 290 ret = 1; 291 unlock_page(page); 292 continue; 293 } 294 295 if (wbc->sync_mode != WB_SYNC_NONE) 296 wait_on_page_writeback(page); 297 298 if (PageWriteback(page) || 299 !clear_page_dirty_for_io(page)) { 300 unlock_page(page); 301 continue; 302 } 303 304 /* Is the page fully outside i_size? (truncate in progress) */ 305 if (page->index > end_index || (page->index == end_index && !offset)) { 306 page->mapping->a_ops->invalidatepage(page, 0); 307 unlock_page(page); 308 continue; 309 } 310 311 ret = __gfs2_jdata_writepage(page, wbc); 312 313 if (ret || (--(wbc->nr_to_write) <= 0)) 314 ret = 1; 315 } 316 gfs2_trans_end(sdp); 317 return ret; 318 } 319 320 /** 321 * gfs2_write_cache_jdata - Like write_cache_pages but different 322 * @mapping: The mapping to write 323 * @wbc: The writeback control 324 * @writepage: The writepage function to call 325 * @data: The data to pass to writepage 326 * 327 * The reason that we use our own function here is that we need to 328 * start transactions before we grab page locks. This allows us 329 * to get the ordering right. 330 */ 331 332 static int gfs2_write_cache_jdata(struct address_space *mapping, 333 struct writeback_control *wbc) 334 { 335 int ret = 0; 336 int done = 0; 337 struct pagevec pvec; 338 int nr_pages; 339 pgoff_t index; 340 pgoff_t end; 341 int scanned = 0; 342 int range_whole = 0; 343 344 pagevec_init(&pvec, 0); 345 if (wbc->range_cyclic) { 346 index = mapping->writeback_index; /* Start from prev offset */ 347 end = -1; 348 } else { 349 index = wbc->range_start >> PAGE_CACHE_SHIFT; 350 end = wbc->range_end >> PAGE_CACHE_SHIFT; 351 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) 352 range_whole = 1; 353 scanned = 1; 354 } 355 356 retry: 357 while (!done && (index <= end) && 358 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, 359 PAGECACHE_TAG_DIRTY, 360 min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1))) { 361 scanned = 1; 362 ret = gfs2_write_jdata_pagevec(mapping, wbc, &pvec, nr_pages, end); 363 if (ret) 364 done = 1; 365 if (ret > 0) 366 ret = 0; 367 368 pagevec_release(&pvec); 369 cond_resched(); 370 } 371 372 if (!scanned && !done) { 373 /* 374 * We hit the last page and there is more work to be done: wrap 375 * back to the start of the file 376 */ 377 scanned = 1; 378 index = 0; 379 goto retry; 380 } 381 382 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) 383 mapping->writeback_index = index; 384 return ret; 385 } 386 387 388 /** 389 * gfs2_jdata_writepages - Write a bunch of dirty pages back to disk 390 * @mapping: The mapping to write 391 * @wbc: The writeback control 392 * 393 */ 394 395 static int gfs2_jdata_writepages(struct address_space *mapping, 396 struct writeback_control *wbc) 397 { 398 struct gfs2_inode *ip = GFS2_I(mapping->host); 399 struct gfs2_sbd *sdp = GFS2_SB(mapping->host); 400 int ret; 401 402 ret = gfs2_write_cache_jdata(mapping, wbc); 403 if (ret == 0 && wbc->sync_mode == WB_SYNC_ALL) { 404 gfs2_log_flush(sdp, ip->i_gl); 405 ret = gfs2_write_cache_jdata(mapping, wbc); 406 } 407 return ret; 408 } 409 410 /** 411 * stuffed_readpage - Fill in a Linux page with stuffed file data 412 * @ip: the inode 413 * @page: the page 414 * 415 * Returns: errno 416 */ 417 418 static int stuffed_readpage(struct gfs2_inode *ip, struct page *page) 419 { 420 struct buffer_head *dibh; 421 u64 dsize = i_size_read(&ip->i_inode); 422 void *kaddr; 423 int error; 424 425 /* 426 * Due to the order of unstuffing files and ->fault(), we can be 427 * asked for a zero page in the case of a stuffed file being extended, 428 * so we need to supply one here. It doesn't happen often. 429 */ 430 if (unlikely(page->index)) { 431 zero_user(page, 0, PAGE_CACHE_SIZE); 432 SetPageUptodate(page); 433 return 0; 434 } 435 436 error = gfs2_meta_inode_buffer(ip, &dibh); 437 if (error) 438 return error; 439 440 kaddr = kmap_atomic(page, KM_USER0); 441 if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode))) 442 dsize = (dibh->b_size - sizeof(struct gfs2_dinode)); 443 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize); 444 memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize); 445 kunmap_atomic(kaddr, KM_USER0); 446 flush_dcache_page(page); 447 brelse(dibh); 448 SetPageUptodate(page); 449 450 return 0; 451 } 452 453 454 /** 455 * __gfs2_readpage - readpage 456 * @file: The file to read a page for 457 * @page: The page to read 458 * 459 * This is the core of gfs2's readpage. Its used by the internal file 460 * reading code as in that case we already hold the glock. Also its 461 * called by gfs2_readpage() once the required lock has been granted. 462 * 463 */ 464 465 static int __gfs2_readpage(void *file, struct page *page) 466 { 467 struct gfs2_inode *ip = GFS2_I(page->mapping->host); 468 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host); 469 int error; 470 471 if (gfs2_is_stuffed(ip)) { 472 error = stuffed_readpage(ip, page); 473 unlock_page(page); 474 } else { 475 error = mpage_readpage(page, gfs2_block_map); 476 } 477 478 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) 479 return -EIO; 480 481 return error; 482 } 483 484 /** 485 * gfs2_readpage - read a page of a file 486 * @file: The file to read 487 * @page: The page of the file 488 * 489 * This deals with the locking required. We have to unlock and 490 * relock the page in order to get the locking in the right 491 * order. 492 */ 493 494 static int gfs2_readpage(struct file *file, struct page *page) 495 { 496 struct address_space *mapping = page->mapping; 497 struct gfs2_inode *ip = GFS2_I(mapping->host); 498 struct gfs2_holder gh; 499 int error; 500 501 unlock_page(page); 502 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh); 503 error = gfs2_glock_nq(&gh); 504 if (unlikely(error)) 505 goto out; 506 error = AOP_TRUNCATED_PAGE; 507 lock_page(page); 508 if (page->mapping == mapping && !PageUptodate(page)) 509 error = __gfs2_readpage(file, page); 510 else 511 unlock_page(page); 512 gfs2_glock_dq(&gh); 513 out: 514 gfs2_holder_uninit(&gh); 515 if (error && error != AOP_TRUNCATED_PAGE) 516 lock_page(page); 517 return error; 518 } 519 520 /** 521 * gfs2_internal_read - read an internal file 522 * @ip: The gfs2 inode 523 * @ra_state: The readahead state (or NULL for no readahead) 524 * @buf: The buffer to fill 525 * @pos: The file position 526 * @size: The amount to read 527 * 528 */ 529 530 int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state, 531 char *buf, loff_t *pos, unsigned size) 532 { 533 struct address_space *mapping = ip->i_inode.i_mapping; 534 unsigned long index = *pos / PAGE_CACHE_SIZE; 535 unsigned offset = *pos & (PAGE_CACHE_SIZE - 1); 536 unsigned copied = 0; 537 unsigned amt; 538 struct page *page; 539 void *p; 540 541 do { 542 amt = size - copied; 543 if (offset + size > PAGE_CACHE_SIZE) 544 amt = PAGE_CACHE_SIZE - offset; 545 page = read_cache_page(mapping, index, __gfs2_readpage, NULL); 546 if (IS_ERR(page)) 547 return PTR_ERR(page); 548 p = kmap_atomic(page, KM_USER0); 549 memcpy(buf + copied, p + offset, amt); 550 kunmap_atomic(p, KM_USER0); 551 mark_page_accessed(page); 552 page_cache_release(page); 553 copied += amt; 554 index++; 555 offset = 0; 556 } while(copied < size); 557 (*pos) += size; 558 return size; 559 } 560 561 /** 562 * gfs2_readpages - Read a bunch of pages at once 563 * 564 * Some notes: 565 * 1. This is only for readahead, so we can simply ignore any things 566 * which are slightly inconvenient (such as locking conflicts between 567 * the page lock and the glock) and return having done no I/O. Its 568 * obviously not something we'd want to do on too regular a basis. 569 * Any I/O we ignore at this time will be done via readpage later. 570 * 2. We don't handle stuffed files here we let readpage do the honours. 571 * 3. mpage_readpages() does most of the heavy lifting in the common case. 572 * 4. gfs2_block_map() is relied upon to set BH_Boundary in the right places. 573 */ 574 575 static int gfs2_readpages(struct file *file, struct address_space *mapping, 576 struct list_head *pages, unsigned nr_pages) 577 { 578 struct inode *inode = mapping->host; 579 struct gfs2_inode *ip = GFS2_I(inode); 580 struct gfs2_sbd *sdp = GFS2_SB(inode); 581 struct gfs2_holder gh; 582 int ret; 583 584 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh); 585 ret = gfs2_glock_nq(&gh); 586 if (unlikely(ret)) 587 goto out_uninit; 588 if (!gfs2_is_stuffed(ip)) 589 ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map); 590 gfs2_glock_dq(&gh); 591 out_uninit: 592 gfs2_holder_uninit(&gh); 593 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) 594 ret = -EIO; 595 return ret; 596 } 597 598 /** 599 * gfs2_write_begin - Begin to write to a file 600 * @file: The file to write to 601 * @mapping: The mapping in which to write 602 * @pos: The file offset at which to start writing 603 * @len: Length of the write 604 * @flags: Various flags 605 * @pagep: Pointer to return the page 606 * @fsdata: Pointer to return fs data (unused by GFS2) 607 * 608 * Returns: errno 609 */ 610 611 static int gfs2_write_begin(struct file *file, struct address_space *mapping, 612 loff_t pos, unsigned len, unsigned flags, 613 struct page **pagep, void **fsdata) 614 { 615 struct gfs2_inode *ip = GFS2_I(mapping->host); 616 struct gfs2_sbd *sdp = GFS2_SB(mapping->host); 617 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 618 unsigned int data_blocks = 0, ind_blocks = 0, rblocks; 619 int alloc_required; 620 int error = 0; 621 struct gfs2_alloc *al; 622 pgoff_t index = pos >> PAGE_CACHE_SHIFT; 623 unsigned from = pos & (PAGE_CACHE_SIZE - 1); 624 unsigned to = from + len; 625 struct page *page; 626 627 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh); 628 error = gfs2_glock_nq(&ip->i_gh); 629 if (unlikely(error)) 630 goto out_uninit; 631 if (&ip->i_inode == sdp->sd_rindex) { 632 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 633 GL_NOCACHE, &m_ip->i_gh); 634 if (unlikely(error)) { 635 gfs2_glock_dq(&ip->i_gh); 636 goto out_uninit; 637 } 638 } 639 640 error = gfs2_write_alloc_required(ip, pos, len, &alloc_required); 641 if (error) 642 goto out_unlock; 643 644 if (alloc_required || gfs2_is_jdata(ip)) 645 gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks); 646 647 if (alloc_required) { 648 al = gfs2_alloc_get(ip); 649 if (!al) { 650 error = -ENOMEM; 651 goto out_unlock; 652 } 653 654 error = gfs2_quota_lock_check(ip); 655 if (error) 656 goto out_alloc_put; 657 658 al->al_requested = data_blocks + ind_blocks; 659 error = gfs2_inplace_reserve(ip); 660 if (error) 661 goto out_qunlock; 662 } 663 664 rblocks = RES_DINODE + ind_blocks; 665 if (gfs2_is_jdata(ip)) 666 rblocks += data_blocks ? data_blocks : 1; 667 if (ind_blocks || data_blocks) 668 rblocks += RES_STATFS + RES_QUOTA; 669 if (&ip->i_inode == sdp->sd_rindex) 670 rblocks += 2 * RES_STATFS; 671 672 error = gfs2_trans_begin(sdp, rblocks, 673 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize); 674 if (error) 675 goto out_trans_fail; 676 677 error = -ENOMEM; 678 flags |= AOP_FLAG_NOFS; 679 page = grab_cache_page_write_begin(mapping, index, flags); 680 *pagep = page; 681 if (unlikely(!page)) 682 goto out_endtrans; 683 684 if (gfs2_is_stuffed(ip)) { 685 error = 0; 686 if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) { 687 error = gfs2_unstuff_dinode(ip, page); 688 if (error == 0) 689 goto prepare_write; 690 } else if (!PageUptodate(page)) { 691 error = stuffed_readpage(ip, page); 692 } 693 goto out; 694 } 695 696 prepare_write: 697 error = block_prepare_write(page, from, to, gfs2_block_map); 698 out: 699 if (error == 0) 700 return 0; 701 702 page_cache_release(page); 703 704 /* 705 * XXX(truncate): the call below should probably be replaced with 706 * a call to the gfs2-specific truncate blocks helper to actually 707 * release disk blocks.. 708 */ 709 if (pos + len > ip->i_inode.i_size) 710 truncate_setsize(&ip->i_inode, ip->i_inode.i_size); 711 out_endtrans: 712 gfs2_trans_end(sdp); 713 out_trans_fail: 714 if (alloc_required) { 715 gfs2_inplace_release(ip); 716 out_qunlock: 717 gfs2_quota_unlock(ip); 718 out_alloc_put: 719 gfs2_alloc_put(ip); 720 } 721 out_unlock: 722 if (&ip->i_inode == sdp->sd_rindex) { 723 gfs2_glock_dq(&m_ip->i_gh); 724 gfs2_holder_uninit(&m_ip->i_gh); 725 } 726 gfs2_glock_dq(&ip->i_gh); 727 out_uninit: 728 gfs2_holder_uninit(&ip->i_gh); 729 return error; 730 } 731 732 /** 733 * adjust_fs_space - Adjusts the free space available due to gfs2_grow 734 * @inode: the rindex inode 735 */ 736 static void adjust_fs_space(struct inode *inode) 737 { 738 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info; 739 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 740 struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 741 struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 742 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 743 struct buffer_head *m_bh, *l_bh; 744 u64 fs_total, new_free; 745 746 /* Total up the file system space, according to the latest rindex. */ 747 fs_total = gfs2_ri_total(sdp); 748 if (gfs2_meta_inode_buffer(m_ip, &m_bh) != 0) 749 return; 750 751 spin_lock(&sdp->sd_statfs_spin); 752 gfs2_statfs_change_in(m_sc, m_bh->b_data + 753 sizeof(struct gfs2_dinode)); 754 if (fs_total > (m_sc->sc_total + l_sc->sc_total)) 755 new_free = fs_total - (m_sc->sc_total + l_sc->sc_total); 756 else 757 new_free = 0; 758 spin_unlock(&sdp->sd_statfs_spin); 759 fs_warn(sdp, "File system extended by %llu blocks.\n", 760 (unsigned long long)new_free); 761 gfs2_statfs_change(sdp, new_free, new_free, 0); 762 763 if (gfs2_meta_inode_buffer(l_ip, &l_bh) != 0) 764 goto out; 765 update_statfs(sdp, m_bh, l_bh); 766 brelse(l_bh); 767 out: 768 brelse(m_bh); 769 } 770 771 /** 772 * gfs2_stuffed_write_end - Write end for stuffed files 773 * @inode: The inode 774 * @dibh: The buffer_head containing the on-disk inode 775 * @pos: The file position 776 * @len: The length of the write 777 * @copied: How much was actually copied by the VFS 778 * @page: The page 779 * 780 * This copies the data from the page into the inode block after 781 * the inode data structure itself. 782 * 783 * Returns: errno 784 */ 785 static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh, 786 loff_t pos, unsigned len, unsigned copied, 787 struct page *page) 788 { 789 struct gfs2_inode *ip = GFS2_I(inode); 790 struct gfs2_sbd *sdp = GFS2_SB(inode); 791 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 792 u64 to = pos + copied; 793 void *kaddr; 794 unsigned char *buf = dibh->b_data + sizeof(struct gfs2_dinode); 795 struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data; 796 797 BUG_ON((pos + len) > (dibh->b_size - sizeof(struct gfs2_dinode))); 798 kaddr = kmap_atomic(page, KM_USER0); 799 memcpy(buf + pos, kaddr + pos, copied); 800 memset(kaddr + pos + copied, 0, len - copied); 801 flush_dcache_page(page); 802 kunmap_atomic(kaddr, KM_USER0); 803 804 if (!PageUptodate(page)) 805 SetPageUptodate(page); 806 unlock_page(page); 807 page_cache_release(page); 808 809 if (copied) { 810 if (inode->i_size < to) { 811 i_size_write(inode, to); 812 ip->i_disksize = inode->i_size; 813 } 814 gfs2_dinode_out(ip, di); 815 mark_inode_dirty(inode); 816 } 817 818 if (inode == sdp->sd_rindex) { 819 adjust_fs_space(inode); 820 ip->i_gh.gh_flags |= GL_NOCACHE; 821 } 822 823 brelse(dibh); 824 gfs2_trans_end(sdp); 825 if (inode == sdp->sd_rindex) { 826 gfs2_glock_dq(&m_ip->i_gh); 827 gfs2_holder_uninit(&m_ip->i_gh); 828 } 829 gfs2_glock_dq(&ip->i_gh); 830 gfs2_holder_uninit(&ip->i_gh); 831 return copied; 832 } 833 834 /** 835 * gfs2_write_end 836 * @file: The file to write to 837 * @mapping: The address space to write to 838 * @pos: The file position 839 * @len: The length of the data 840 * @copied: 841 * @page: The page that has been written 842 * @fsdata: The fsdata (unused in GFS2) 843 * 844 * The main write_end function for GFS2. We have a separate one for 845 * stuffed files as they are slightly different, otherwise we just 846 * put our locking around the VFS provided functions. 847 * 848 * Returns: errno 849 */ 850 851 static int gfs2_write_end(struct file *file, struct address_space *mapping, 852 loff_t pos, unsigned len, unsigned copied, 853 struct page *page, void *fsdata) 854 { 855 struct inode *inode = page->mapping->host; 856 struct gfs2_inode *ip = GFS2_I(inode); 857 struct gfs2_sbd *sdp = GFS2_SB(inode); 858 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 859 struct buffer_head *dibh; 860 struct gfs2_alloc *al = ip->i_alloc; 861 unsigned int from = pos & (PAGE_CACHE_SIZE - 1); 862 unsigned int to = from + len; 863 int ret; 864 865 BUG_ON(gfs2_glock_is_locked_by_me(ip->i_gl) == NULL); 866 867 ret = gfs2_meta_inode_buffer(ip, &dibh); 868 if (unlikely(ret)) { 869 unlock_page(page); 870 page_cache_release(page); 871 goto failed; 872 } 873 874 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 875 876 if (gfs2_is_stuffed(ip)) 877 return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page); 878 879 if (!gfs2_is_writeback(ip)) 880 gfs2_page_add_databufs(ip, page, from, to); 881 882 ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata); 883 if (ret > 0) { 884 if (inode->i_size > ip->i_disksize) 885 ip->i_disksize = inode->i_size; 886 gfs2_dinode_out(ip, dibh->b_data); 887 mark_inode_dirty(inode); 888 } 889 890 if (inode == sdp->sd_rindex) { 891 adjust_fs_space(inode); 892 ip->i_gh.gh_flags |= GL_NOCACHE; 893 } 894 895 brelse(dibh); 896 gfs2_trans_end(sdp); 897 failed: 898 if (al) { 899 gfs2_inplace_release(ip); 900 gfs2_quota_unlock(ip); 901 gfs2_alloc_put(ip); 902 } 903 if (inode == sdp->sd_rindex) { 904 gfs2_glock_dq(&m_ip->i_gh); 905 gfs2_holder_uninit(&m_ip->i_gh); 906 } 907 gfs2_glock_dq(&ip->i_gh); 908 gfs2_holder_uninit(&ip->i_gh); 909 return ret; 910 } 911 912 /** 913 * gfs2_set_page_dirty - Page dirtying function 914 * @page: The page to dirty 915 * 916 * Returns: 1 if it dirtyed the page, or 0 otherwise 917 */ 918 919 static int gfs2_set_page_dirty(struct page *page) 920 { 921 SetPageChecked(page); 922 return __set_page_dirty_buffers(page); 923 } 924 925 /** 926 * gfs2_bmap - Block map function 927 * @mapping: Address space info 928 * @lblock: The block to map 929 * 930 * Returns: The disk address for the block or 0 on hole or error 931 */ 932 933 static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock) 934 { 935 struct gfs2_inode *ip = GFS2_I(mapping->host); 936 struct gfs2_holder i_gh; 937 sector_t dblock = 0; 938 int error; 939 940 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); 941 if (error) 942 return 0; 943 944 if (!gfs2_is_stuffed(ip)) 945 dblock = generic_block_bmap(mapping, lblock, gfs2_block_map); 946 947 gfs2_glock_dq_uninit(&i_gh); 948 949 return dblock; 950 } 951 952 static void gfs2_discard(struct gfs2_sbd *sdp, struct buffer_head *bh) 953 { 954 struct gfs2_bufdata *bd; 955 956 lock_buffer(bh); 957 gfs2_log_lock(sdp); 958 clear_buffer_dirty(bh); 959 bd = bh->b_private; 960 if (bd) { 961 if (!list_empty(&bd->bd_le.le_list) && !buffer_pinned(bh)) 962 list_del_init(&bd->bd_le.le_list); 963 else 964 gfs2_remove_from_journal(bh, current->journal_info, 0); 965 } 966 bh->b_bdev = NULL; 967 clear_buffer_mapped(bh); 968 clear_buffer_req(bh); 969 clear_buffer_new(bh); 970 gfs2_log_unlock(sdp); 971 unlock_buffer(bh); 972 } 973 974 static void gfs2_invalidatepage(struct page *page, unsigned long offset) 975 { 976 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host); 977 struct buffer_head *bh, *head; 978 unsigned long pos = 0; 979 980 BUG_ON(!PageLocked(page)); 981 if (offset == 0) 982 ClearPageChecked(page); 983 if (!page_has_buffers(page)) 984 goto out; 985 986 bh = head = page_buffers(page); 987 do { 988 if (offset <= pos) 989 gfs2_discard(sdp, bh); 990 pos += bh->b_size; 991 bh = bh->b_this_page; 992 } while (bh != head); 993 out: 994 if (offset == 0) 995 try_to_release_page(page, 0); 996 } 997 998 /** 999 * gfs2_ok_for_dio - check that dio is valid on this file 1000 * @ip: The inode 1001 * @rw: READ or WRITE 1002 * @offset: The offset at which we are reading or writing 1003 * 1004 * Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o) 1005 * 1 (to accept the i/o request) 1006 */ 1007 static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset) 1008 { 1009 /* 1010 * Should we return an error here? I can't see that O_DIRECT for 1011 * a stuffed file makes any sense. For now we'll silently fall 1012 * back to buffered I/O 1013 */ 1014 if (gfs2_is_stuffed(ip)) 1015 return 0; 1016 1017 if (offset >= i_size_read(&ip->i_inode)) 1018 return 0; 1019 return 1; 1020 } 1021 1022 1023 1024 static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb, 1025 const struct iovec *iov, loff_t offset, 1026 unsigned long nr_segs) 1027 { 1028 struct file *file = iocb->ki_filp; 1029 struct inode *inode = file->f_mapping->host; 1030 struct gfs2_inode *ip = GFS2_I(inode); 1031 struct gfs2_holder gh; 1032 int rv; 1033 1034 /* 1035 * Deferred lock, even if its a write, since we do no allocation 1036 * on this path. All we need change is atime, and this lock mode 1037 * ensures that other nodes have flushed their buffered read caches 1038 * (i.e. their page cache entries for this inode). We do not, 1039 * unfortunately have the option of only flushing a range like 1040 * the VFS does. 1041 */ 1042 gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, &gh); 1043 rv = gfs2_glock_nq(&gh); 1044 if (rv) 1045 return rv; 1046 rv = gfs2_ok_for_dio(ip, rw, offset); 1047 if (rv != 1) 1048 goto out; /* dio not valid, fall back to buffered i/o */ 1049 1050 rv = __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 1051 offset, nr_segs, gfs2_get_block_direct, 1052 NULL, NULL, 0); 1053 out: 1054 gfs2_glock_dq_m(1, &gh); 1055 gfs2_holder_uninit(&gh); 1056 return rv; 1057 } 1058 1059 /** 1060 * gfs2_releasepage - free the metadata associated with a page 1061 * @page: the page that's being released 1062 * @gfp_mask: passed from Linux VFS, ignored by us 1063 * 1064 * Call try_to_free_buffers() if the buffers in this page can be 1065 * released. 1066 * 1067 * Returns: 0 1068 */ 1069 1070 int gfs2_releasepage(struct page *page, gfp_t gfp_mask) 1071 { 1072 struct address_space *mapping = page->mapping; 1073 struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping); 1074 struct buffer_head *bh, *head; 1075 struct gfs2_bufdata *bd; 1076 1077 if (!page_has_buffers(page)) 1078 return 0; 1079 1080 gfs2_log_lock(sdp); 1081 head = bh = page_buffers(page); 1082 do { 1083 if (atomic_read(&bh->b_count)) 1084 goto cannot_release; 1085 bd = bh->b_private; 1086 if (bd && bd->bd_ail) 1087 goto cannot_release; 1088 gfs2_assert_warn(sdp, !buffer_pinned(bh)); 1089 gfs2_assert_warn(sdp, !buffer_dirty(bh)); 1090 bh = bh->b_this_page; 1091 } while(bh != head); 1092 gfs2_log_unlock(sdp); 1093 1094 head = bh = page_buffers(page); 1095 do { 1096 gfs2_log_lock(sdp); 1097 bd = bh->b_private; 1098 if (bd) { 1099 gfs2_assert_warn(sdp, bd->bd_bh == bh); 1100 gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr)); 1101 if (!list_empty(&bd->bd_le.le_list)) { 1102 if (!buffer_pinned(bh)) 1103 list_del_init(&bd->bd_le.le_list); 1104 else 1105 bd = NULL; 1106 } 1107 if (bd) 1108 bd->bd_bh = NULL; 1109 bh->b_private = NULL; 1110 } 1111 gfs2_log_unlock(sdp); 1112 if (bd) 1113 kmem_cache_free(gfs2_bufdata_cachep, bd); 1114 1115 bh = bh->b_this_page; 1116 } while (bh != head); 1117 1118 return try_to_free_buffers(page); 1119 cannot_release: 1120 gfs2_log_unlock(sdp); 1121 return 0; 1122 } 1123 1124 static const struct address_space_operations gfs2_writeback_aops = { 1125 .writepage = gfs2_writeback_writepage, 1126 .writepages = gfs2_writeback_writepages, 1127 .readpage = gfs2_readpage, 1128 .readpages = gfs2_readpages, 1129 .sync_page = block_sync_page, 1130 .write_begin = gfs2_write_begin, 1131 .write_end = gfs2_write_end, 1132 .bmap = gfs2_bmap, 1133 .invalidatepage = gfs2_invalidatepage, 1134 .releasepage = gfs2_releasepage, 1135 .direct_IO = gfs2_direct_IO, 1136 .migratepage = buffer_migrate_page, 1137 .is_partially_uptodate = block_is_partially_uptodate, 1138 .error_remove_page = generic_error_remove_page, 1139 }; 1140 1141 static const struct address_space_operations gfs2_ordered_aops = { 1142 .writepage = gfs2_ordered_writepage, 1143 .readpage = gfs2_readpage, 1144 .readpages = gfs2_readpages, 1145 .sync_page = block_sync_page, 1146 .write_begin = gfs2_write_begin, 1147 .write_end = gfs2_write_end, 1148 .set_page_dirty = gfs2_set_page_dirty, 1149 .bmap = gfs2_bmap, 1150 .invalidatepage = gfs2_invalidatepage, 1151 .releasepage = gfs2_releasepage, 1152 .direct_IO = gfs2_direct_IO, 1153 .migratepage = buffer_migrate_page, 1154 .is_partially_uptodate = block_is_partially_uptodate, 1155 .error_remove_page = generic_error_remove_page, 1156 }; 1157 1158 static const struct address_space_operations gfs2_jdata_aops = { 1159 .writepage = gfs2_jdata_writepage, 1160 .writepages = gfs2_jdata_writepages, 1161 .readpage = gfs2_readpage, 1162 .readpages = gfs2_readpages, 1163 .sync_page = block_sync_page, 1164 .write_begin = gfs2_write_begin, 1165 .write_end = gfs2_write_end, 1166 .set_page_dirty = gfs2_set_page_dirty, 1167 .bmap = gfs2_bmap, 1168 .invalidatepage = gfs2_invalidatepage, 1169 .releasepage = gfs2_releasepage, 1170 .is_partially_uptodate = block_is_partially_uptodate, 1171 .error_remove_page = generic_error_remove_page, 1172 }; 1173 1174 void gfs2_set_aops(struct inode *inode) 1175 { 1176 struct gfs2_inode *ip = GFS2_I(inode); 1177 1178 if (gfs2_is_writeback(ip)) 1179 inode->i_mapping->a_ops = &gfs2_writeback_aops; 1180 else if (gfs2_is_ordered(ip)) 1181 inode->i_mapping->a_ops = &gfs2_ordered_aops; 1182 else if (gfs2_is_jdata(ip)) 1183 inode->i_mapping->a_ops = &gfs2_jdata_aops; 1184 else 1185 BUG(); 1186 } 1187 1188