aops.c revision 0cf2f7632b1789b811ab20b611c4156e6de2b055
1/* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public 8 * License as published by the Free Software Foundation; either 9 * version 2 of the License, or (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 GNU 14 * General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public 17 * License along with this program; if not, write to the 18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 19 * Boston, MA 021110-1307, USA. 20 */ 21 22#include <linux/fs.h> 23#include <linux/slab.h> 24#include <linux/highmem.h> 25#include <linux/pagemap.h> 26#include <asm/byteorder.h> 27#include <linux/swap.h> 28#include <linux/pipe_fs_i.h> 29#include <linux/mpage.h> 30#include <linux/quotaops.h> 31 32#define MLOG_MASK_PREFIX ML_FILE_IO 33#include <cluster/masklog.h> 34 35#include "ocfs2.h" 36 37#include "alloc.h" 38#include "aops.h" 39#include "dlmglue.h" 40#include "extent_map.h" 41#include "file.h" 42#include "inode.h" 43#include "journal.h" 44#include "suballoc.h" 45#include "super.h" 46#include "symlink.h" 47 48#include "buffer_head_io.h" 49 50static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock, 51 struct buffer_head *bh_result, int create) 52{ 53 int err = -EIO; 54 int status; 55 struct ocfs2_dinode *fe = NULL; 56 struct buffer_head *bh = NULL; 57 struct buffer_head *buffer_cache_bh = NULL; 58 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 59 void *kaddr; 60 61 mlog_entry("(0x%p, %llu, 0x%p, %d)\n", inode, 62 (unsigned long long)iblock, bh_result, create); 63 64 BUG_ON(ocfs2_inode_is_fast_symlink(inode)); 65 66 if ((iblock << inode->i_sb->s_blocksize_bits) > PATH_MAX + 1) { 67 mlog(ML_ERROR, "block offset > PATH_MAX: %llu", 68 (unsigned long long)iblock); 69 goto bail; 70 } 71 72 status = ocfs2_read_inode_block(inode, &bh); 73 if (status < 0) { 74 mlog_errno(status); 75 goto bail; 76 } 77 fe = (struct ocfs2_dinode *) bh->b_data; 78 79 if ((u64)iblock >= ocfs2_clusters_to_blocks(inode->i_sb, 80 le32_to_cpu(fe->i_clusters))) { 81 mlog(ML_ERROR, "block offset is outside the allocated size: " 82 "%llu\n", (unsigned long long)iblock); 83 goto bail; 84 } 85 86 /* We don't use the page cache to create symlink data, so if 87 * need be, copy it over from the buffer cache. */ 88 if (!buffer_uptodate(bh_result) && ocfs2_inode_is_new(inode)) { 89 u64 blkno = le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) + 90 iblock; 91 buffer_cache_bh = sb_getblk(osb->sb, blkno); 92 if (!buffer_cache_bh) { 93 mlog(ML_ERROR, "couldn't getblock for symlink!\n"); 94 goto bail; 95 } 96 97 /* we haven't locked out transactions, so a commit 98 * could've happened. Since we've got a reference on 99 * the bh, even if it commits while we're doing the 100 * copy, the data is still good. */ 101 if (buffer_jbd(buffer_cache_bh) 102 && ocfs2_inode_is_new(inode)) { 103 kaddr = kmap_atomic(bh_result->b_page, KM_USER0); 104 if (!kaddr) { 105 mlog(ML_ERROR, "couldn't kmap!\n"); 106 goto bail; 107 } 108 memcpy(kaddr + (bh_result->b_size * iblock), 109 buffer_cache_bh->b_data, 110 bh_result->b_size); 111 kunmap_atomic(kaddr, KM_USER0); 112 set_buffer_uptodate(bh_result); 113 } 114 brelse(buffer_cache_bh); 115 } 116 117 map_bh(bh_result, inode->i_sb, 118 le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) + iblock); 119 120 err = 0; 121 122bail: 123 brelse(bh); 124 125 mlog_exit(err); 126 return err; 127} 128 129static int ocfs2_get_block(struct inode *inode, sector_t iblock, 130 struct buffer_head *bh_result, int create) 131{ 132 int err = 0; 133 unsigned int ext_flags; 134 u64 max_blocks = bh_result->b_size >> inode->i_blkbits; 135 u64 p_blkno, count, past_eof; 136 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 137 138 mlog_entry("(0x%p, %llu, 0x%p, %d)\n", inode, 139 (unsigned long long)iblock, bh_result, create); 140 141 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE) 142 mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n", 143 inode, inode->i_ino); 144 145 if (S_ISLNK(inode->i_mode)) { 146 /* this always does I/O for some reason. */ 147 err = ocfs2_symlink_get_block(inode, iblock, bh_result, create); 148 goto bail; 149 } 150 151 err = ocfs2_extent_map_get_blocks(inode, iblock, &p_blkno, &count, 152 &ext_flags); 153 if (err) { 154 mlog(ML_ERROR, "Error %d from get_blocks(0x%p, %llu, 1, " 155 "%llu, NULL)\n", err, inode, (unsigned long long)iblock, 156 (unsigned long long)p_blkno); 157 goto bail; 158 } 159 160 if (max_blocks < count) 161 count = max_blocks; 162 163 /* 164 * ocfs2 never allocates in this function - the only time we 165 * need to use BH_New is when we're extending i_size on a file 166 * system which doesn't support holes, in which case BH_New 167 * allows block_prepare_write() to zero. 168 * 169 * If we see this on a sparse file system, then a truncate has 170 * raced us and removed the cluster. In this case, we clear 171 * the buffers dirty and uptodate bits and let the buffer code 172 * ignore it as a hole. 173 */ 174 if (create && p_blkno == 0 && ocfs2_sparse_alloc(osb)) { 175 clear_buffer_dirty(bh_result); 176 clear_buffer_uptodate(bh_result); 177 goto bail; 178 } 179 180 /* Treat the unwritten extent as a hole for zeroing purposes. */ 181 if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN)) 182 map_bh(bh_result, inode->i_sb, p_blkno); 183 184 bh_result->b_size = count << inode->i_blkbits; 185 186 if (!ocfs2_sparse_alloc(osb)) { 187 if (p_blkno == 0) { 188 err = -EIO; 189 mlog(ML_ERROR, 190 "iblock = %llu p_blkno = %llu blkno=(%llu)\n", 191 (unsigned long long)iblock, 192 (unsigned long long)p_blkno, 193 (unsigned long long)OCFS2_I(inode)->ip_blkno); 194 mlog(ML_ERROR, "Size %llu, clusters %u\n", (unsigned long long)i_size_read(inode), OCFS2_I(inode)->ip_clusters); 195 dump_stack(); 196 goto bail; 197 } 198 199 past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode)); 200 mlog(0, "Inode %lu, past_eof = %llu\n", inode->i_ino, 201 (unsigned long long)past_eof); 202 203 if (create && (iblock >= past_eof)) 204 set_buffer_new(bh_result); 205 } 206 207bail: 208 if (err < 0) 209 err = -EIO; 210 211 mlog_exit(err); 212 return err; 213} 214 215int ocfs2_read_inline_data(struct inode *inode, struct page *page, 216 struct buffer_head *di_bh) 217{ 218 void *kaddr; 219 loff_t size; 220 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 221 222 if (!(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL)) { 223 ocfs2_error(inode->i_sb, "Inode %llu lost inline data flag", 224 (unsigned long long)OCFS2_I(inode)->ip_blkno); 225 return -EROFS; 226 } 227 228 size = i_size_read(inode); 229 230 if (size > PAGE_CACHE_SIZE || 231 size > ocfs2_max_inline_data_with_xattr(inode->i_sb, di)) { 232 ocfs2_error(inode->i_sb, 233 "Inode %llu has with inline data has bad size: %Lu", 234 (unsigned long long)OCFS2_I(inode)->ip_blkno, 235 (unsigned long long)size); 236 return -EROFS; 237 } 238 239 kaddr = kmap_atomic(page, KM_USER0); 240 if (size) 241 memcpy(kaddr, di->id2.i_data.id_data, size); 242 /* Clear the remaining part of the page */ 243 memset(kaddr + size, 0, PAGE_CACHE_SIZE - size); 244 flush_dcache_page(page); 245 kunmap_atomic(kaddr, KM_USER0); 246 247 SetPageUptodate(page); 248 249 return 0; 250} 251 252static int ocfs2_readpage_inline(struct inode *inode, struct page *page) 253{ 254 int ret; 255 struct buffer_head *di_bh = NULL; 256 257 BUG_ON(!PageLocked(page)); 258 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)); 259 260 ret = ocfs2_read_inode_block(inode, &di_bh); 261 if (ret) { 262 mlog_errno(ret); 263 goto out; 264 } 265 266 ret = ocfs2_read_inline_data(inode, page, di_bh); 267out: 268 unlock_page(page); 269 270 brelse(di_bh); 271 return ret; 272} 273 274static int ocfs2_readpage(struct file *file, struct page *page) 275{ 276 struct inode *inode = page->mapping->host; 277 struct ocfs2_inode_info *oi = OCFS2_I(inode); 278 loff_t start = (loff_t)page->index << PAGE_CACHE_SHIFT; 279 int ret, unlock = 1; 280 281 mlog_entry("(0x%p, %lu)\n", file, (page ? page->index : 0)); 282 283 ret = ocfs2_inode_lock_with_page(inode, NULL, 0, page); 284 if (ret != 0) { 285 if (ret == AOP_TRUNCATED_PAGE) 286 unlock = 0; 287 mlog_errno(ret); 288 goto out; 289 } 290 291 if (down_read_trylock(&oi->ip_alloc_sem) == 0) { 292 ret = AOP_TRUNCATED_PAGE; 293 goto out_inode_unlock; 294 } 295 296 /* 297 * i_size might have just been updated as we grabed the meta lock. We 298 * might now be discovering a truncate that hit on another node. 299 * block_read_full_page->get_block freaks out if it is asked to read 300 * beyond the end of a file, so we check here. Callers 301 * (generic_file_read, vm_ops->fault) are clever enough to check i_size 302 * and notice that the page they just read isn't needed. 303 * 304 * XXX sys_readahead() seems to get that wrong? 305 */ 306 if (start >= i_size_read(inode)) { 307 zero_user(page, 0, PAGE_SIZE); 308 SetPageUptodate(page); 309 ret = 0; 310 goto out_alloc; 311 } 312 313 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) 314 ret = ocfs2_readpage_inline(inode, page); 315 else 316 ret = block_read_full_page(page, ocfs2_get_block); 317 unlock = 0; 318 319out_alloc: 320 up_read(&OCFS2_I(inode)->ip_alloc_sem); 321out_inode_unlock: 322 ocfs2_inode_unlock(inode, 0); 323out: 324 if (unlock) 325 unlock_page(page); 326 mlog_exit(ret); 327 return ret; 328} 329 330/* 331 * This is used only for read-ahead. Failures or difficult to handle 332 * situations are safe to ignore. 333 * 334 * Right now, we don't bother with BH_Boundary - in-inode extent lists 335 * are quite large (243 extents on 4k blocks), so most inodes don't 336 * grow out to a tree. If need be, detecting boundary extents could 337 * trivially be added in a future version of ocfs2_get_block(). 338 */ 339static int ocfs2_readpages(struct file *filp, struct address_space *mapping, 340 struct list_head *pages, unsigned nr_pages) 341{ 342 int ret, err = -EIO; 343 struct inode *inode = mapping->host; 344 struct ocfs2_inode_info *oi = OCFS2_I(inode); 345 loff_t start; 346 struct page *last; 347 348 /* 349 * Use the nonblocking flag for the dlm code to avoid page 350 * lock inversion, but don't bother with retrying. 351 */ 352 ret = ocfs2_inode_lock_full(inode, NULL, 0, OCFS2_LOCK_NONBLOCK); 353 if (ret) 354 return err; 355 356 if (down_read_trylock(&oi->ip_alloc_sem) == 0) { 357 ocfs2_inode_unlock(inode, 0); 358 return err; 359 } 360 361 /* 362 * Don't bother with inline-data. There isn't anything 363 * to read-ahead in that case anyway... 364 */ 365 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) 366 goto out_unlock; 367 368 /* 369 * Check whether a remote node truncated this file - we just 370 * drop out in that case as it's not worth handling here. 371 */ 372 last = list_entry(pages->prev, struct page, lru); 373 start = (loff_t)last->index << PAGE_CACHE_SHIFT; 374 if (start >= i_size_read(inode)) 375 goto out_unlock; 376 377 err = mpage_readpages(mapping, pages, nr_pages, ocfs2_get_block); 378 379out_unlock: 380 up_read(&oi->ip_alloc_sem); 381 ocfs2_inode_unlock(inode, 0); 382 383 return err; 384} 385 386/* Note: Because we don't support holes, our allocation has 387 * already happened (allocation writes zeros to the file data) 388 * so we don't have to worry about ordered writes in 389 * ocfs2_writepage. 390 * 391 * ->writepage is called during the process of invalidating the page cache 392 * during blocked lock processing. It can't block on any cluster locks 393 * to during block mapping. It's relying on the fact that the block 394 * mapping can't have disappeared under the dirty pages that it is 395 * being asked to write back. 396 */ 397static int ocfs2_writepage(struct page *page, struct writeback_control *wbc) 398{ 399 int ret; 400 401 mlog_entry("(0x%p)\n", page); 402 403 ret = block_write_full_page(page, ocfs2_get_block, wbc); 404 405 mlog_exit(ret); 406 407 return ret; 408} 409 410/* 411 * This is called from ocfs2_write_zero_page() which has handled it's 412 * own cluster locking and has ensured allocation exists for those 413 * blocks to be written. 414 */ 415int ocfs2_prepare_write_nolock(struct inode *inode, struct page *page, 416 unsigned from, unsigned to) 417{ 418 int ret; 419 420 ret = block_prepare_write(page, from, to, ocfs2_get_block); 421 422 return ret; 423} 424 425/* Taken from ext3. We don't necessarily need the full blown 426 * functionality yet, but IMHO it's better to cut and paste the whole 427 * thing so we can avoid introducing our own bugs (and easily pick up 428 * their fixes when they happen) --Mark */ 429int walk_page_buffers( handle_t *handle, 430 struct buffer_head *head, 431 unsigned from, 432 unsigned to, 433 int *partial, 434 int (*fn)( handle_t *handle, 435 struct buffer_head *bh)) 436{ 437 struct buffer_head *bh; 438 unsigned block_start, block_end; 439 unsigned blocksize = head->b_size; 440 int err, ret = 0; 441 struct buffer_head *next; 442 443 for ( bh = head, block_start = 0; 444 ret == 0 && (bh != head || !block_start); 445 block_start = block_end, bh = next) 446 { 447 next = bh->b_this_page; 448 block_end = block_start + blocksize; 449 if (block_end <= from || block_start >= to) { 450 if (partial && !buffer_uptodate(bh)) 451 *partial = 1; 452 continue; 453 } 454 err = (*fn)(handle, bh); 455 if (!ret) 456 ret = err; 457 } 458 return ret; 459} 460 461handle_t *ocfs2_start_walk_page_trans(struct inode *inode, 462 struct page *page, 463 unsigned from, 464 unsigned to) 465{ 466 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 467 handle_t *handle; 468 int ret = 0; 469 470 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 471 if (IS_ERR(handle)) { 472 ret = -ENOMEM; 473 mlog_errno(ret); 474 goto out; 475 } 476 477 if (ocfs2_should_order_data(inode)) { 478 ret = ocfs2_jbd2_file_inode(handle, inode); 479 if (ret < 0) 480 mlog_errno(ret); 481 } 482out: 483 if (ret) { 484 if (!IS_ERR(handle)) 485 ocfs2_commit_trans(osb, handle); 486 handle = ERR_PTR(ret); 487 } 488 return handle; 489} 490 491static sector_t ocfs2_bmap(struct address_space *mapping, sector_t block) 492{ 493 sector_t status; 494 u64 p_blkno = 0; 495 int err = 0; 496 struct inode *inode = mapping->host; 497 498 mlog_entry("(block = %llu)\n", (unsigned long long)block); 499 500 /* We don't need to lock journal system files, since they aren't 501 * accessed concurrently from multiple nodes. 502 */ 503 if (!INODE_JOURNAL(inode)) { 504 err = ocfs2_inode_lock(inode, NULL, 0); 505 if (err) { 506 if (err != -ENOENT) 507 mlog_errno(err); 508 goto bail; 509 } 510 down_read(&OCFS2_I(inode)->ip_alloc_sem); 511 } 512 513 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)) 514 err = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL, 515 NULL); 516 517 if (!INODE_JOURNAL(inode)) { 518 up_read(&OCFS2_I(inode)->ip_alloc_sem); 519 ocfs2_inode_unlock(inode, 0); 520 } 521 522 if (err) { 523 mlog(ML_ERROR, "get_blocks() failed, block = %llu\n", 524 (unsigned long long)block); 525 mlog_errno(err); 526 goto bail; 527 } 528 529bail: 530 status = err ? 0 : p_blkno; 531 532 mlog_exit((int)status); 533 534 return status; 535} 536 537/* 538 * TODO: Make this into a generic get_blocks function. 539 * 540 * From do_direct_io in direct-io.c: 541 * "So what we do is to permit the ->get_blocks function to populate 542 * bh.b_size with the size of IO which is permitted at this offset and 543 * this i_blkbits." 544 * 545 * This function is called directly from get_more_blocks in direct-io.c. 546 * 547 * called like this: dio->get_blocks(dio->inode, fs_startblk, 548 * fs_count, map_bh, dio->rw == WRITE); 549 */ 550static int ocfs2_direct_IO_get_blocks(struct inode *inode, sector_t iblock, 551 struct buffer_head *bh_result, int create) 552{ 553 int ret; 554 u64 p_blkno, inode_blocks, contig_blocks; 555 unsigned int ext_flags; 556 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; 557 unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits; 558 559 /* This function won't even be called if the request isn't all 560 * nicely aligned and of the right size, so there's no need 561 * for us to check any of that. */ 562 563 inode_blocks = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode)); 564 565 /* 566 * Any write past EOF is not allowed because we'd be extending. 567 */ 568 if (create && (iblock + max_blocks) > inode_blocks) { 569 ret = -EIO; 570 goto bail; 571 } 572 573 /* This figures out the size of the next contiguous block, and 574 * our logical offset */ 575 ret = ocfs2_extent_map_get_blocks(inode, iblock, &p_blkno, 576 &contig_blocks, &ext_flags); 577 if (ret) { 578 mlog(ML_ERROR, "get_blocks() failed iblock=%llu\n", 579 (unsigned long long)iblock); 580 ret = -EIO; 581 goto bail; 582 } 583 584 if (!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)) && !p_blkno && create) { 585 ocfs2_error(inode->i_sb, 586 "Inode %llu has a hole at block %llu\n", 587 (unsigned long long)OCFS2_I(inode)->ip_blkno, 588 (unsigned long long)iblock); 589 ret = -EROFS; 590 goto bail; 591 } 592 593 /* 594 * get_more_blocks() expects us to describe a hole by clearing 595 * the mapped bit on bh_result(). 596 * 597 * Consider an unwritten extent as a hole. 598 */ 599 if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN)) 600 map_bh(bh_result, inode->i_sb, p_blkno); 601 else { 602 /* 603 * ocfs2_prepare_inode_for_write() should have caught 604 * the case where we'd be filling a hole and triggered 605 * a buffered write instead. 606 */ 607 if (create) { 608 ret = -EIO; 609 mlog_errno(ret); 610 goto bail; 611 } 612 613 clear_buffer_mapped(bh_result); 614 } 615 616 /* make sure we don't map more than max_blocks blocks here as 617 that's all the kernel will handle at this point. */ 618 if (max_blocks < contig_blocks) 619 contig_blocks = max_blocks; 620 bh_result->b_size = contig_blocks << blocksize_bits; 621bail: 622 return ret; 623} 624 625/* 626 * ocfs2_dio_end_io is called by the dio core when a dio is finished. We're 627 * particularly interested in the aio/dio case. Like the core uses 628 * i_alloc_sem, we use the rw_lock DLM lock to protect io on one node from 629 * truncation on another. 630 */ 631static void ocfs2_dio_end_io(struct kiocb *iocb, 632 loff_t offset, 633 ssize_t bytes, 634 void *private) 635{ 636 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode; 637 int level; 638 639 /* this io's submitter should not have unlocked this before we could */ 640 BUG_ON(!ocfs2_iocb_is_rw_locked(iocb)); 641 642 ocfs2_iocb_clear_rw_locked(iocb); 643 644 level = ocfs2_iocb_rw_locked_level(iocb); 645 if (!level) 646 up_read(&inode->i_alloc_sem); 647 ocfs2_rw_unlock(inode, level); 648} 649 650/* 651 * ocfs2_invalidatepage() and ocfs2_releasepage() are shamelessly stolen 652 * from ext3. PageChecked() bits have been removed as OCFS2 does not 653 * do journalled data. 654 */ 655static void ocfs2_invalidatepage(struct page *page, unsigned long offset) 656{ 657 journal_t *journal = OCFS2_SB(page->mapping->host->i_sb)->journal->j_journal; 658 659 jbd2_journal_invalidatepage(journal, page, offset); 660} 661 662static int ocfs2_releasepage(struct page *page, gfp_t wait) 663{ 664 journal_t *journal = OCFS2_SB(page->mapping->host->i_sb)->journal->j_journal; 665 666 if (!page_has_buffers(page)) 667 return 0; 668 return jbd2_journal_try_to_free_buffers(journal, page, wait); 669} 670 671static ssize_t ocfs2_direct_IO(int rw, 672 struct kiocb *iocb, 673 const struct iovec *iov, 674 loff_t offset, 675 unsigned long nr_segs) 676{ 677 struct file *file = iocb->ki_filp; 678 struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host; 679 int ret; 680 681 mlog_entry_void(); 682 683 /* 684 * Fallback to buffered I/O if we see an inode without 685 * extents. 686 */ 687 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) 688 return 0; 689 690 ret = blockdev_direct_IO_no_locking(rw, iocb, inode, 691 inode->i_sb->s_bdev, iov, offset, 692 nr_segs, 693 ocfs2_direct_IO_get_blocks, 694 ocfs2_dio_end_io); 695 696 mlog_exit(ret); 697 return ret; 698} 699 700static void ocfs2_figure_cluster_boundaries(struct ocfs2_super *osb, 701 u32 cpos, 702 unsigned int *start, 703 unsigned int *end) 704{ 705 unsigned int cluster_start = 0, cluster_end = PAGE_CACHE_SIZE; 706 707 if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits)) { 708 unsigned int cpp; 709 710 cpp = 1 << (PAGE_CACHE_SHIFT - osb->s_clustersize_bits); 711 712 cluster_start = cpos % cpp; 713 cluster_start = cluster_start << osb->s_clustersize_bits; 714 715 cluster_end = cluster_start + osb->s_clustersize; 716 } 717 718 BUG_ON(cluster_start > PAGE_SIZE); 719 BUG_ON(cluster_end > PAGE_SIZE); 720 721 if (start) 722 *start = cluster_start; 723 if (end) 724 *end = cluster_end; 725} 726 727/* 728 * 'from' and 'to' are the region in the page to avoid zeroing. 729 * 730 * If pagesize > clustersize, this function will avoid zeroing outside 731 * of the cluster boundary. 732 * 733 * from == to == 0 is code for "zero the entire cluster region" 734 */ 735static void ocfs2_clear_page_regions(struct page *page, 736 struct ocfs2_super *osb, u32 cpos, 737 unsigned from, unsigned to) 738{ 739 void *kaddr; 740 unsigned int cluster_start, cluster_end; 741 742 ocfs2_figure_cluster_boundaries(osb, cpos, &cluster_start, &cluster_end); 743 744 kaddr = kmap_atomic(page, KM_USER0); 745 746 if (from || to) { 747 if (from > cluster_start) 748 memset(kaddr + cluster_start, 0, from - cluster_start); 749 if (to < cluster_end) 750 memset(kaddr + to, 0, cluster_end - to); 751 } else { 752 memset(kaddr + cluster_start, 0, cluster_end - cluster_start); 753 } 754 755 kunmap_atomic(kaddr, KM_USER0); 756} 757 758/* 759 * Nonsparse file systems fully allocate before we get to the write 760 * code. This prevents ocfs2_write() from tagging the write as an 761 * allocating one, which means ocfs2_map_page_blocks() might try to 762 * read-in the blocks at the tail of our file. Avoid reading them by 763 * testing i_size against each block offset. 764 */ 765static int ocfs2_should_read_blk(struct inode *inode, struct page *page, 766 unsigned int block_start) 767{ 768 u64 offset = page_offset(page) + block_start; 769 770 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))) 771 return 1; 772 773 if (i_size_read(inode) > offset) 774 return 1; 775 776 return 0; 777} 778 779/* 780 * Some of this taken from block_prepare_write(). We already have our 781 * mapping by now though, and the entire write will be allocating or 782 * it won't, so not much need to use BH_New. 783 * 784 * This will also skip zeroing, which is handled externally. 785 */ 786int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno, 787 struct inode *inode, unsigned int from, 788 unsigned int to, int new) 789{ 790 int ret = 0; 791 struct buffer_head *head, *bh, *wait[2], **wait_bh = wait; 792 unsigned int block_end, block_start; 793 unsigned int bsize = 1 << inode->i_blkbits; 794 795 if (!page_has_buffers(page)) 796 create_empty_buffers(page, bsize, 0); 797 798 head = page_buffers(page); 799 for (bh = head, block_start = 0; bh != head || !block_start; 800 bh = bh->b_this_page, block_start += bsize) { 801 block_end = block_start + bsize; 802 803 clear_buffer_new(bh); 804 805 /* 806 * Ignore blocks outside of our i/o range - 807 * they may belong to unallocated clusters. 808 */ 809 if (block_start >= to || block_end <= from) { 810 if (PageUptodate(page)) 811 set_buffer_uptodate(bh); 812 continue; 813 } 814 815 /* 816 * For an allocating write with cluster size >= page 817 * size, we always write the entire page. 818 */ 819 if (new) 820 set_buffer_new(bh); 821 822 if (!buffer_mapped(bh)) { 823 map_bh(bh, inode->i_sb, *p_blkno); 824 unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr); 825 } 826 827 if (PageUptodate(page)) { 828 if (!buffer_uptodate(bh)) 829 set_buffer_uptodate(bh); 830 } else if (!buffer_uptodate(bh) && !buffer_delay(bh) && 831 !buffer_new(bh) && 832 ocfs2_should_read_blk(inode, page, block_start) && 833 (block_start < from || block_end > to)) { 834 ll_rw_block(READ, 1, &bh); 835 *wait_bh++=bh; 836 } 837 838 *p_blkno = *p_blkno + 1; 839 } 840 841 /* 842 * If we issued read requests - let them complete. 843 */ 844 while(wait_bh > wait) { 845 wait_on_buffer(*--wait_bh); 846 if (!buffer_uptodate(*wait_bh)) 847 ret = -EIO; 848 } 849 850 if (ret == 0 || !new) 851 return ret; 852 853 /* 854 * If we get -EIO above, zero out any newly allocated blocks 855 * to avoid exposing stale data. 856 */ 857 bh = head; 858 block_start = 0; 859 do { 860 block_end = block_start + bsize; 861 if (block_end <= from) 862 goto next_bh; 863 if (block_start >= to) 864 break; 865 866 zero_user(page, block_start, bh->b_size); 867 set_buffer_uptodate(bh); 868 mark_buffer_dirty(bh); 869 870next_bh: 871 block_start = block_end; 872 bh = bh->b_this_page; 873 } while (bh != head); 874 875 return ret; 876} 877 878#if (PAGE_CACHE_SIZE >= OCFS2_MAX_CLUSTERSIZE) 879#define OCFS2_MAX_CTXT_PAGES 1 880#else 881#define OCFS2_MAX_CTXT_PAGES (OCFS2_MAX_CLUSTERSIZE / PAGE_CACHE_SIZE) 882#endif 883 884#define OCFS2_MAX_CLUSTERS_PER_PAGE (PAGE_CACHE_SIZE / OCFS2_MIN_CLUSTERSIZE) 885 886/* 887 * Describe the state of a single cluster to be written to. 888 */ 889struct ocfs2_write_cluster_desc { 890 u32 c_cpos; 891 u32 c_phys; 892 /* 893 * Give this a unique field because c_phys eventually gets 894 * filled. 895 */ 896 unsigned c_new; 897 unsigned c_unwritten; 898 unsigned c_needs_zero; 899}; 900 901struct ocfs2_write_ctxt { 902 /* Logical cluster position / len of write */ 903 u32 w_cpos; 904 u32 w_clen; 905 906 /* First cluster allocated in a nonsparse extend */ 907 u32 w_first_new_cpos; 908 909 struct ocfs2_write_cluster_desc w_desc[OCFS2_MAX_CLUSTERS_PER_PAGE]; 910 911 /* 912 * This is true if page_size > cluster_size. 913 * 914 * It triggers a set of special cases during write which might 915 * have to deal with allocating writes to partial pages. 916 */ 917 unsigned int w_large_pages; 918 919 /* 920 * Pages involved in this write. 921 * 922 * w_target_page is the page being written to by the user. 923 * 924 * w_pages is an array of pages which always contains 925 * w_target_page, and in the case of an allocating write with 926 * page_size < cluster size, it will contain zero'd and mapped 927 * pages adjacent to w_target_page which need to be written 928 * out in so that future reads from that region will get 929 * zero's. 930 */ 931 struct page *w_pages[OCFS2_MAX_CTXT_PAGES]; 932 unsigned int w_num_pages; 933 struct page *w_target_page; 934 935 /* 936 * ocfs2_write_end() uses this to know what the real range to 937 * write in the target should be. 938 */ 939 unsigned int w_target_from; 940 unsigned int w_target_to; 941 942 /* 943 * We could use journal_current_handle() but this is cleaner, 944 * IMHO -Mark 945 */ 946 handle_t *w_handle; 947 948 struct buffer_head *w_di_bh; 949 950 struct ocfs2_cached_dealloc_ctxt w_dealloc; 951}; 952 953void ocfs2_unlock_and_free_pages(struct page **pages, int num_pages) 954{ 955 int i; 956 957 for(i = 0; i < num_pages; i++) { 958 if (pages[i]) { 959 unlock_page(pages[i]); 960 mark_page_accessed(pages[i]); 961 page_cache_release(pages[i]); 962 } 963 } 964} 965 966static void ocfs2_free_write_ctxt(struct ocfs2_write_ctxt *wc) 967{ 968 ocfs2_unlock_and_free_pages(wc->w_pages, wc->w_num_pages); 969 970 brelse(wc->w_di_bh); 971 kfree(wc); 972} 973 974static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp, 975 struct ocfs2_super *osb, loff_t pos, 976 unsigned len, struct buffer_head *di_bh) 977{ 978 u32 cend; 979 struct ocfs2_write_ctxt *wc; 980 981 wc = kzalloc(sizeof(struct ocfs2_write_ctxt), GFP_NOFS); 982 if (!wc) 983 return -ENOMEM; 984 985 wc->w_cpos = pos >> osb->s_clustersize_bits; 986 wc->w_first_new_cpos = UINT_MAX; 987 cend = (pos + len - 1) >> osb->s_clustersize_bits; 988 wc->w_clen = cend - wc->w_cpos + 1; 989 get_bh(di_bh); 990 wc->w_di_bh = di_bh; 991 992 if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits)) 993 wc->w_large_pages = 1; 994 else 995 wc->w_large_pages = 0; 996 997 ocfs2_init_dealloc_ctxt(&wc->w_dealloc); 998 999 *wcp = wc; 1000 1001 return 0; 1002} 1003 1004/* 1005 * If a page has any new buffers, zero them out here, and mark them uptodate 1006 * and dirty so they'll be written out (in order to prevent uninitialised 1007 * block data from leaking). And clear the new bit. 1008 */ 1009static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to) 1010{ 1011 unsigned int block_start, block_end; 1012 struct buffer_head *head, *bh; 1013 1014 BUG_ON(!PageLocked(page)); 1015 if (!page_has_buffers(page)) 1016 return; 1017 1018 bh = head = page_buffers(page); 1019 block_start = 0; 1020 do { 1021 block_end = block_start + bh->b_size; 1022 1023 if (buffer_new(bh)) { 1024 if (block_end > from && block_start < to) { 1025 if (!PageUptodate(page)) { 1026 unsigned start, end; 1027 1028 start = max(from, block_start); 1029 end = min(to, block_end); 1030 1031 zero_user_segment(page, start, end); 1032 set_buffer_uptodate(bh); 1033 } 1034 1035 clear_buffer_new(bh); 1036 mark_buffer_dirty(bh); 1037 } 1038 } 1039 1040 block_start = block_end; 1041 bh = bh->b_this_page; 1042 } while (bh != head); 1043} 1044 1045/* 1046 * Only called when we have a failure during allocating write to write 1047 * zero's to the newly allocated region. 1048 */ 1049static void ocfs2_write_failure(struct inode *inode, 1050 struct ocfs2_write_ctxt *wc, 1051 loff_t user_pos, unsigned user_len) 1052{ 1053 int i; 1054 unsigned from = user_pos & (PAGE_CACHE_SIZE - 1), 1055 to = user_pos + user_len; 1056 struct page *tmppage; 1057 1058 ocfs2_zero_new_buffers(wc->w_target_page, from, to); 1059 1060 for(i = 0; i < wc->w_num_pages; i++) { 1061 tmppage = wc->w_pages[i]; 1062 1063 if (page_has_buffers(tmppage)) { 1064 if (ocfs2_should_order_data(inode)) 1065 ocfs2_jbd2_file_inode(wc->w_handle, inode); 1066 1067 block_commit_write(tmppage, from, to); 1068 } 1069 } 1070} 1071 1072static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno, 1073 struct ocfs2_write_ctxt *wc, 1074 struct page *page, u32 cpos, 1075 loff_t user_pos, unsigned user_len, 1076 int new) 1077{ 1078 int ret; 1079 unsigned int map_from = 0, map_to = 0; 1080 unsigned int cluster_start, cluster_end; 1081 unsigned int user_data_from = 0, user_data_to = 0; 1082 1083 ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), cpos, 1084 &cluster_start, &cluster_end); 1085 1086 if (page == wc->w_target_page) { 1087 map_from = user_pos & (PAGE_CACHE_SIZE - 1); 1088 map_to = map_from + user_len; 1089 1090 if (new) 1091 ret = ocfs2_map_page_blocks(page, p_blkno, inode, 1092 cluster_start, cluster_end, 1093 new); 1094 else 1095 ret = ocfs2_map_page_blocks(page, p_blkno, inode, 1096 map_from, map_to, new); 1097 if (ret) { 1098 mlog_errno(ret); 1099 goto out; 1100 } 1101 1102 user_data_from = map_from; 1103 user_data_to = map_to; 1104 if (new) { 1105 map_from = cluster_start; 1106 map_to = cluster_end; 1107 } 1108 } else { 1109 /* 1110 * If we haven't allocated the new page yet, we 1111 * shouldn't be writing it out without copying user 1112 * data. This is likely a math error from the caller. 1113 */ 1114 BUG_ON(!new); 1115 1116 map_from = cluster_start; 1117 map_to = cluster_end; 1118 1119 ret = ocfs2_map_page_blocks(page, p_blkno, inode, 1120 cluster_start, cluster_end, new); 1121 if (ret) { 1122 mlog_errno(ret); 1123 goto out; 1124 } 1125 } 1126 1127 /* 1128 * Parts of newly allocated pages need to be zero'd. 1129 * 1130 * Above, we have also rewritten 'to' and 'from' - as far as 1131 * the rest of the function is concerned, the entire cluster 1132 * range inside of a page needs to be written. 1133 * 1134 * We can skip this if the page is up to date - it's already 1135 * been zero'd from being read in as a hole. 1136 */ 1137 if (new && !PageUptodate(page)) 1138 ocfs2_clear_page_regions(page, OCFS2_SB(inode->i_sb), 1139 cpos, user_data_from, user_data_to); 1140 1141 flush_dcache_page(page); 1142 1143out: 1144 return ret; 1145} 1146 1147/* 1148 * This function will only grab one clusters worth of pages. 1149 */ 1150static int ocfs2_grab_pages_for_write(struct address_space *mapping, 1151 struct ocfs2_write_ctxt *wc, 1152 u32 cpos, loff_t user_pos, int new, 1153 struct page *mmap_page) 1154{ 1155 int ret = 0, i; 1156 unsigned long start, target_index, index; 1157 struct inode *inode = mapping->host; 1158 1159 target_index = user_pos >> PAGE_CACHE_SHIFT; 1160 1161 /* 1162 * Figure out how many pages we'll be manipulating here. For 1163 * non allocating write, we just change the one 1164 * page. Otherwise, we'll need a whole clusters worth. 1165 */ 1166 if (new) { 1167 wc->w_num_pages = ocfs2_pages_per_cluster(inode->i_sb); 1168 start = ocfs2_align_clusters_to_page_index(inode->i_sb, cpos); 1169 } else { 1170 wc->w_num_pages = 1; 1171 start = target_index; 1172 } 1173 1174 for(i = 0; i < wc->w_num_pages; i++) { 1175 index = start + i; 1176 1177 if (index == target_index && mmap_page) { 1178 /* 1179 * ocfs2_pagemkwrite() is a little different 1180 * and wants us to directly use the page 1181 * passed in. 1182 */ 1183 lock_page(mmap_page); 1184 1185 if (mmap_page->mapping != mapping) { 1186 unlock_page(mmap_page); 1187 /* 1188 * Sanity check - the locking in 1189 * ocfs2_pagemkwrite() should ensure 1190 * that this code doesn't trigger. 1191 */ 1192 ret = -EINVAL; 1193 mlog_errno(ret); 1194 goto out; 1195 } 1196 1197 page_cache_get(mmap_page); 1198 wc->w_pages[i] = mmap_page; 1199 } else { 1200 wc->w_pages[i] = find_or_create_page(mapping, index, 1201 GFP_NOFS); 1202 if (!wc->w_pages[i]) { 1203 ret = -ENOMEM; 1204 mlog_errno(ret); 1205 goto out; 1206 } 1207 } 1208 1209 if (index == target_index) 1210 wc->w_target_page = wc->w_pages[i]; 1211 } 1212out: 1213 return ret; 1214} 1215 1216/* 1217 * Prepare a single cluster for write one cluster into the file. 1218 */ 1219static int ocfs2_write_cluster(struct address_space *mapping, 1220 u32 phys, unsigned int unwritten, 1221 unsigned int should_zero, 1222 struct ocfs2_alloc_context *data_ac, 1223 struct ocfs2_alloc_context *meta_ac, 1224 struct ocfs2_write_ctxt *wc, u32 cpos, 1225 loff_t user_pos, unsigned user_len) 1226{ 1227 int ret, i, new; 1228 u64 v_blkno, p_blkno; 1229 struct inode *inode = mapping->host; 1230 struct ocfs2_extent_tree et; 1231 1232 new = phys == 0 ? 1 : 0; 1233 if (new) { 1234 u32 tmp_pos; 1235 1236 /* 1237 * This is safe to call with the page locks - it won't take 1238 * any additional semaphores or cluster locks. 1239 */ 1240 tmp_pos = cpos; 1241 ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode, 1242 &tmp_pos, 1, 0, wc->w_di_bh, 1243 wc->w_handle, data_ac, 1244 meta_ac, NULL); 1245 /* 1246 * This shouldn't happen because we must have already 1247 * calculated the correct meta data allocation required. The 1248 * internal tree allocation code should know how to increase 1249 * transaction credits itself. 1250 * 1251 * If need be, we could handle -EAGAIN for a 1252 * RESTART_TRANS here. 1253 */ 1254 mlog_bug_on_msg(ret == -EAGAIN, 1255 "Inode %llu: EAGAIN return during allocation.\n", 1256 (unsigned long long)OCFS2_I(inode)->ip_blkno); 1257 if (ret < 0) { 1258 mlog_errno(ret); 1259 goto out; 1260 } 1261 } else if (unwritten) { 1262 ocfs2_init_dinode_extent_tree(&et, inode, wc->w_di_bh); 1263 ret = ocfs2_mark_extent_written(inode, &et, 1264 wc->w_handle, cpos, 1, phys, 1265 meta_ac, &wc->w_dealloc); 1266 if (ret < 0) { 1267 mlog_errno(ret); 1268 goto out; 1269 } 1270 } 1271 1272 if (should_zero) 1273 v_blkno = ocfs2_clusters_to_blocks(inode->i_sb, cpos); 1274 else 1275 v_blkno = user_pos >> inode->i_sb->s_blocksize_bits; 1276 1277 /* 1278 * The only reason this should fail is due to an inability to 1279 * find the extent added. 1280 */ 1281 ret = ocfs2_extent_map_get_blocks(inode, v_blkno, &p_blkno, NULL, 1282 NULL); 1283 if (ret < 0) { 1284 ocfs2_error(inode->i_sb, "Corrupting extend for inode %llu, " 1285 "at logical block %llu", 1286 (unsigned long long)OCFS2_I(inode)->ip_blkno, 1287 (unsigned long long)v_blkno); 1288 goto out; 1289 } 1290 1291 BUG_ON(p_blkno == 0); 1292 1293 for(i = 0; i < wc->w_num_pages; i++) { 1294 int tmpret; 1295 1296 tmpret = ocfs2_prepare_page_for_write(inode, &p_blkno, wc, 1297 wc->w_pages[i], cpos, 1298 user_pos, user_len, 1299 should_zero); 1300 if (tmpret) { 1301 mlog_errno(tmpret); 1302 if (ret == 0) 1303 ret = tmpret; 1304 } 1305 } 1306 1307 /* 1308 * We only have cleanup to do in case of allocating write. 1309 */ 1310 if (ret && new) 1311 ocfs2_write_failure(inode, wc, user_pos, user_len); 1312 1313out: 1314 1315 return ret; 1316} 1317 1318static int ocfs2_write_cluster_by_desc(struct address_space *mapping, 1319 struct ocfs2_alloc_context *data_ac, 1320 struct ocfs2_alloc_context *meta_ac, 1321 struct ocfs2_write_ctxt *wc, 1322 loff_t pos, unsigned len) 1323{ 1324 int ret, i; 1325 loff_t cluster_off; 1326 unsigned int local_len = len; 1327 struct ocfs2_write_cluster_desc *desc; 1328 struct ocfs2_super *osb = OCFS2_SB(mapping->host->i_sb); 1329 1330 for (i = 0; i < wc->w_clen; i++) { 1331 desc = &wc->w_desc[i]; 1332 1333 /* 1334 * We have to make sure that the total write passed in 1335 * doesn't extend past a single cluster. 1336 */ 1337 local_len = len; 1338 cluster_off = pos & (osb->s_clustersize - 1); 1339 if ((cluster_off + local_len) > osb->s_clustersize) 1340 local_len = osb->s_clustersize - cluster_off; 1341 1342 ret = ocfs2_write_cluster(mapping, desc->c_phys, 1343 desc->c_unwritten, 1344 desc->c_needs_zero, 1345 data_ac, meta_ac, 1346 wc, desc->c_cpos, pos, local_len); 1347 if (ret) { 1348 mlog_errno(ret); 1349 goto out; 1350 } 1351 1352 len -= local_len; 1353 pos += local_len; 1354 } 1355 1356 ret = 0; 1357out: 1358 return ret; 1359} 1360 1361/* 1362 * ocfs2_write_end() wants to know which parts of the target page it 1363 * should complete the write on. It's easiest to compute them ahead of 1364 * time when a more complete view of the write is available. 1365 */ 1366static void ocfs2_set_target_boundaries(struct ocfs2_super *osb, 1367 struct ocfs2_write_ctxt *wc, 1368 loff_t pos, unsigned len, int alloc) 1369{ 1370 struct ocfs2_write_cluster_desc *desc; 1371 1372 wc->w_target_from = pos & (PAGE_CACHE_SIZE - 1); 1373 wc->w_target_to = wc->w_target_from + len; 1374 1375 if (alloc == 0) 1376 return; 1377 1378 /* 1379 * Allocating write - we may have different boundaries based 1380 * on page size and cluster size. 1381 * 1382 * NOTE: We can no longer compute one value from the other as 1383 * the actual write length and user provided length may be 1384 * different. 1385 */ 1386 1387 if (wc->w_large_pages) { 1388 /* 1389 * We only care about the 1st and last cluster within 1390 * our range and whether they should be zero'd or not. Either 1391 * value may be extended out to the start/end of a 1392 * newly allocated cluster. 1393 */ 1394 desc = &wc->w_desc[0]; 1395 if (desc->c_needs_zero) 1396 ocfs2_figure_cluster_boundaries(osb, 1397 desc->c_cpos, 1398 &wc->w_target_from, 1399 NULL); 1400 1401 desc = &wc->w_desc[wc->w_clen - 1]; 1402 if (desc->c_needs_zero) 1403 ocfs2_figure_cluster_boundaries(osb, 1404 desc->c_cpos, 1405 NULL, 1406 &wc->w_target_to); 1407 } else { 1408 wc->w_target_from = 0; 1409 wc->w_target_to = PAGE_CACHE_SIZE; 1410 } 1411} 1412 1413/* 1414 * Populate each single-cluster write descriptor in the write context 1415 * with information about the i/o to be done. 1416 * 1417 * Returns the number of clusters that will have to be allocated, as 1418 * well as a worst case estimate of the number of extent records that 1419 * would have to be created during a write to an unwritten region. 1420 */ 1421static int ocfs2_populate_write_desc(struct inode *inode, 1422 struct ocfs2_write_ctxt *wc, 1423 unsigned int *clusters_to_alloc, 1424 unsigned int *extents_to_split) 1425{ 1426 int ret; 1427 struct ocfs2_write_cluster_desc *desc; 1428 unsigned int num_clusters = 0; 1429 unsigned int ext_flags = 0; 1430 u32 phys = 0; 1431 int i; 1432 1433 *clusters_to_alloc = 0; 1434 *extents_to_split = 0; 1435 1436 for (i = 0; i < wc->w_clen; i++) { 1437 desc = &wc->w_desc[i]; 1438 desc->c_cpos = wc->w_cpos + i; 1439 1440 if (num_clusters == 0) { 1441 /* 1442 * Need to look up the next extent record. 1443 */ 1444 ret = ocfs2_get_clusters(inode, desc->c_cpos, &phys, 1445 &num_clusters, &ext_flags); 1446 if (ret) { 1447 mlog_errno(ret); 1448 goto out; 1449 } 1450 1451 /* 1452 * Assume worst case - that we're writing in 1453 * the middle of the extent. 1454 * 1455 * We can assume that the write proceeds from 1456 * left to right, in which case the extent 1457 * insert code is smart enough to coalesce the 1458 * next splits into the previous records created. 1459 */ 1460 if (ext_flags & OCFS2_EXT_UNWRITTEN) 1461 *extents_to_split = *extents_to_split + 2; 1462 } else if (phys) { 1463 /* 1464 * Only increment phys if it doesn't describe 1465 * a hole. 1466 */ 1467 phys++; 1468 } 1469 1470 /* 1471 * If w_first_new_cpos is < UINT_MAX, we have a non-sparse 1472 * file that got extended. w_first_new_cpos tells us 1473 * where the newly allocated clusters are so we can 1474 * zero them. 1475 */ 1476 if (desc->c_cpos >= wc->w_first_new_cpos) { 1477 BUG_ON(phys == 0); 1478 desc->c_needs_zero = 1; 1479 } 1480 1481 desc->c_phys = phys; 1482 if (phys == 0) { 1483 desc->c_new = 1; 1484 desc->c_needs_zero = 1; 1485 *clusters_to_alloc = *clusters_to_alloc + 1; 1486 } 1487 1488 if (ext_flags & OCFS2_EXT_UNWRITTEN) { 1489 desc->c_unwritten = 1; 1490 desc->c_needs_zero = 1; 1491 } 1492 1493 num_clusters--; 1494 } 1495 1496 ret = 0; 1497out: 1498 return ret; 1499} 1500 1501static int ocfs2_write_begin_inline(struct address_space *mapping, 1502 struct inode *inode, 1503 struct ocfs2_write_ctxt *wc) 1504{ 1505 int ret; 1506 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1507 struct page *page; 1508 handle_t *handle; 1509 struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data; 1510 1511 page = find_or_create_page(mapping, 0, GFP_NOFS); 1512 if (!page) { 1513 ret = -ENOMEM; 1514 mlog_errno(ret); 1515 goto out; 1516 } 1517 /* 1518 * If we don't set w_num_pages then this page won't get unlocked 1519 * and freed on cleanup of the write context. 1520 */ 1521 wc->w_pages[0] = wc->w_target_page = page; 1522 wc->w_num_pages = 1; 1523 1524 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 1525 if (IS_ERR(handle)) { 1526 ret = PTR_ERR(handle); 1527 mlog_errno(ret); 1528 goto out; 1529 } 1530 1531 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), wc->w_di_bh, 1532 OCFS2_JOURNAL_ACCESS_WRITE); 1533 if (ret) { 1534 ocfs2_commit_trans(osb, handle); 1535 1536 mlog_errno(ret); 1537 goto out; 1538 } 1539 1540 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)) 1541 ocfs2_set_inode_data_inline(inode, di); 1542 1543 if (!PageUptodate(page)) { 1544 ret = ocfs2_read_inline_data(inode, page, wc->w_di_bh); 1545 if (ret) { 1546 ocfs2_commit_trans(osb, handle); 1547 1548 goto out; 1549 } 1550 } 1551 1552 wc->w_handle = handle; 1553out: 1554 return ret; 1555} 1556 1557int ocfs2_size_fits_inline_data(struct buffer_head *di_bh, u64 new_size) 1558{ 1559 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 1560 1561 if (new_size <= le16_to_cpu(di->id2.i_data.id_count)) 1562 return 1; 1563 return 0; 1564} 1565 1566static int ocfs2_try_to_write_inline_data(struct address_space *mapping, 1567 struct inode *inode, loff_t pos, 1568 unsigned len, struct page *mmap_page, 1569 struct ocfs2_write_ctxt *wc) 1570{ 1571 int ret, written = 0; 1572 loff_t end = pos + len; 1573 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1574 struct ocfs2_dinode *di = NULL; 1575 1576 mlog(0, "Inode %llu, write of %u bytes at off %llu. features: 0x%x\n", 1577 (unsigned long long)oi->ip_blkno, len, (unsigned long long)pos, 1578 oi->ip_dyn_features); 1579 1580 /* 1581 * Handle inodes which already have inline data 1st. 1582 */ 1583 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 1584 if (mmap_page == NULL && 1585 ocfs2_size_fits_inline_data(wc->w_di_bh, end)) 1586 goto do_inline_write; 1587 1588 /* 1589 * The write won't fit - we have to give this inode an 1590 * inline extent list now. 1591 */ 1592 ret = ocfs2_convert_inline_data_to_extents(inode, wc->w_di_bh); 1593 if (ret) 1594 mlog_errno(ret); 1595 goto out; 1596 } 1597 1598 /* 1599 * Check whether the inode can accept inline data. 1600 */ 1601 if (oi->ip_clusters != 0 || i_size_read(inode) != 0) 1602 return 0; 1603 1604 /* 1605 * Check whether the write can fit. 1606 */ 1607 di = (struct ocfs2_dinode *)wc->w_di_bh->b_data; 1608 if (mmap_page || 1609 end > ocfs2_max_inline_data_with_xattr(inode->i_sb, di)) 1610 return 0; 1611 1612do_inline_write: 1613 ret = ocfs2_write_begin_inline(mapping, inode, wc); 1614 if (ret) { 1615 mlog_errno(ret); 1616 goto out; 1617 } 1618 1619 /* 1620 * This signals to the caller that the data can be written 1621 * inline. 1622 */ 1623 written = 1; 1624out: 1625 return written ? written : ret; 1626} 1627 1628/* 1629 * This function only does anything for file systems which can't 1630 * handle sparse files. 1631 * 1632 * What we want to do here is fill in any hole between the current end 1633 * of allocation and the end of our write. That way the rest of the 1634 * write path can treat it as an non-allocating write, which has no 1635 * special case code for sparse/nonsparse files. 1636 */ 1637static int ocfs2_expand_nonsparse_inode(struct inode *inode, loff_t pos, 1638 unsigned len, 1639 struct ocfs2_write_ctxt *wc) 1640{ 1641 int ret; 1642 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1643 loff_t newsize = pos + len; 1644 1645 if (ocfs2_sparse_alloc(osb)) 1646 return 0; 1647 1648 if (newsize <= i_size_read(inode)) 1649 return 0; 1650 1651 ret = ocfs2_extend_no_holes(inode, newsize, pos); 1652 if (ret) 1653 mlog_errno(ret); 1654 1655 wc->w_first_new_cpos = 1656 ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode)); 1657 1658 return ret; 1659} 1660 1661int ocfs2_write_begin_nolock(struct address_space *mapping, 1662 loff_t pos, unsigned len, unsigned flags, 1663 struct page **pagep, void **fsdata, 1664 struct buffer_head *di_bh, struct page *mmap_page) 1665{ 1666 int ret, cluster_of_pages, credits = OCFS2_INODE_UPDATE_CREDITS; 1667 unsigned int clusters_to_alloc, extents_to_split; 1668 struct ocfs2_write_ctxt *wc; 1669 struct inode *inode = mapping->host; 1670 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1671 struct ocfs2_dinode *di; 1672 struct ocfs2_alloc_context *data_ac = NULL; 1673 struct ocfs2_alloc_context *meta_ac = NULL; 1674 handle_t *handle; 1675 struct ocfs2_extent_tree et; 1676 1677 ret = ocfs2_alloc_write_ctxt(&wc, osb, pos, len, di_bh); 1678 if (ret) { 1679 mlog_errno(ret); 1680 return ret; 1681 } 1682 1683 if (ocfs2_supports_inline_data(osb)) { 1684 ret = ocfs2_try_to_write_inline_data(mapping, inode, pos, len, 1685 mmap_page, wc); 1686 if (ret == 1) { 1687 ret = 0; 1688 goto success; 1689 } 1690 if (ret < 0) { 1691 mlog_errno(ret); 1692 goto out; 1693 } 1694 } 1695 1696 ret = ocfs2_expand_nonsparse_inode(inode, pos, len, wc); 1697 if (ret) { 1698 mlog_errno(ret); 1699 goto out; 1700 } 1701 1702 ret = ocfs2_populate_write_desc(inode, wc, &clusters_to_alloc, 1703 &extents_to_split); 1704 if (ret) { 1705 mlog_errno(ret); 1706 goto out; 1707 } 1708 1709 di = (struct ocfs2_dinode *)wc->w_di_bh->b_data; 1710 1711 /* 1712 * We set w_target_from, w_target_to here so that 1713 * ocfs2_write_end() knows which range in the target page to 1714 * write out. An allocation requires that we write the entire 1715 * cluster range. 1716 */ 1717 if (clusters_to_alloc || extents_to_split) { 1718 /* 1719 * XXX: We are stretching the limits of 1720 * ocfs2_lock_allocators(). It greatly over-estimates 1721 * the work to be done. 1722 */ 1723 mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u," 1724 " clusters_to_add = %u, extents_to_split = %u\n", 1725 (unsigned long long)OCFS2_I(inode)->ip_blkno, 1726 (long long)i_size_read(inode), le32_to_cpu(di->i_clusters), 1727 clusters_to_alloc, extents_to_split); 1728 1729 ocfs2_init_dinode_extent_tree(&et, inode, wc->w_di_bh); 1730 ret = ocfs2_lock_allocators(inode, &et, 1731 clusters_to_alloc, extents_to_split, 1732 &data_ac, &meta_ac); 1733 if (ret) { 1734 mlog_errno(ret); 1735 goto out; 1736 } 1737 1738 credits = ocfs2_calc_extend_credits(inode->i_sb, 1739 &di->id2.i_list, 1740 clusters_to_alloc); 1741 1742 } 1743 1744 /* 1745 * We have to zero sparse allocated clusters, unwritten extent clusters, 1746 * and non-sparse clusters we just extended. For non-sparse writes, 1747 * we know zeros will only be needed in the first and/or last cluster. 1748 */ 1749 if (clusters_to_alloc || extents_to_split || 1750 (wc->w_clen && (wc->w_desc[0].c_needs_zero || 1751 wc->w_desc[wc->w_clen - 1].c_needs_zero))) 1752 cluster_of_pages = 1; 1753 else 1754 cluster_of_pages = 0; 1755 1756 ocfs2_set_target_boundaries(osb, wc, pos, len, cluster_of_pages); 1757 1758 handle = ocfs2_start_trans(osb, credits); 1759 if (IS_ERR(handle)) { 1760 ret = PTR_ERR(handle); 1761 mlog_errno(ret); 1762 goto out; 1763 } 1764 1765 wc->w_handle = handle; 1766 1767 if (clusters_to_alloc && vfs_dq_alloc_space_nodirty(inode, 1768 ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc))) { 1769 ret = -EDQUOT; 1770 goto out_commit; 1771 } 1772 /* 1773 * We don't want this to fail in ocfs2_write_end(), so do it 1774 * here. 1775 */ 1776 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), wc->w_di_bh, 1777 OCFS2_JOURNAL_ACCESS_WRITE); 1778 if (ret) { 1779 mlog_errno(ret); 1780 goto out_quota; 1781 } 1782 1783 /* 1784 * Fill our page array first. That way we've grabbed enough so 1785 * that we can zero and flush if we error after adding the 1786 * extent. 1787 */ 1788 ret = ocfs2_grab_pages_for_write(mapping, wc, wc->w_cpos, pos, 1789 cluster_of_pages, mmap_page); 1790 if (ret) { 1791 mlog_errno(ret); 1792 goto out_quota; 1793 } 1794 1795 ret = ocfs2_write_cluster_by_desc(mapping, data_ac, meta_ac, wc, pos, 1796 len); 1797 if (ret) { 1798 mlog_errno(ret); 1799 goto out_quota; 1800 } 1801 1802 if (data_ac) 1803 ocfs2_free_alloc_context(data_ac); 1804 if (meta_ac) 1805 ocfs2_free_alloc_context(meta_ac); 1806 1807success: 1808 *pagep = wc->w_target_page; 1809 *fsdata = wc; 1810 return 0; 1811out_quota: 1812 if (clusters_to_alloc) 1813 vfs_dq_free_space(inode, 1814 ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc)); 1815out_commit: 1816 ocfs2_commit_trans(osb, handle); 1817 1818out: 1819 ocfs2_free_write_ctxt(wc); 1820 1821 if (data_ac) 1822 ocfs2_free_alloc_context(data_ac); 1823 if (meta_ac) 1824 ocfs2_free_alloc_context(meta_ac); 1825 return ret; 1826} 1827 1828static int ocfs2_write_begin(struct file *file, struct address_space *mapping, 1829 loff_t pos, unsigned len, unsigned flags, 1830 struct page **pagep, void **fsdata) 1831{ 1832 int ret; 1833 struct buffer_head *di_bh = NULL; 1834 struct inode *inode = mapping->host; 1835 1836 ret = ocfs2_inode_lock(inode, &di_bh, 1); 1837 if (ret) { 1838 mlog_errno(ret); 1839 return ret; 1840 } 1841 1842 /* 1843 * Take alloc sem here to prevent concurrent lookups. That way 1844 * the mapping, zeroing and tree manipulation within 1845 * ocfs2_write() will be safe against ->readpage(). This 1846 * should also serve to lock out allocation from a shared 1847 * writeable region. 1848 */ 1849 down_write(&OCFS2_I(inode)->ip_alloc_sem); 1850 1851 ret = ocfs2_write_begin_nolock(mapping, pos, len, flags, pagep, 1852 fsdata, di_bh, NULL); 1853 if (ret) { 1854 mlog_errno(ret); 1855 goto out_fail; 1856 } 1857 1858 brelse(di_bh); 1859 1860 return 0; 1861 1862out_fail: 1863 up_write(&OCFS2_I(inode)->ip_alloc_sem); 1864 1865 brelse(di_bh); 1866 ocfs2_inode_unlock(inode, 1); 1867 1868 return ret; 1869} 1870 1871static void ocfs2_write_end_inline(struct inode *inode, loff_t pos, 1872 unsigned len, unsigned *copied, 1873 struct ocfs2_dinode *di, 1874 struct ocfs2_write_ctxt *wc) 1875{ 1876 void *kaddr; 1877 1878 if (unlikely(*copied < len)) { 1879 if (!PageUptodate(wc->w_target_page)) { 1880 *copied = 0; 1881 return; 1882 } 1883 } 1884 1885 kaddr = kmap_atomic(wc->w_target_page, KM_USER0); 1886 memcpy(di->id2.i_data.id_data + pos, kaddr + pos, *copied); 1887 kunmap_atomic(kaddr, KM_USER0); 1888 1889 mlog(0, "Data written to inode at offset %llu. " 1890 "id_count = %u, copied = %u, i_dyn_features = 0x%x\n", 1891 (unsigned long long)pos, *copied, 1892 le16_to_cpu(di->id2.i_data.id_count), 1893 le16_to_cpu(di->i_dyn_features)); 1894} 1895 1896int ocfs2_write_end_nolock(struct address_space *mapping, 1897 loff_t pos, unsigned len, unsigned copied, 1898 struct page *page, void *fsdata) 1899{ 1900 int i; 1901 unsigned from, to, start = pos & (PAGE_CACHE_SIZE - 1); 1902 struct inode *inode = mapping->host; 1903 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1904 struct ocfs2_write_ctxt *wc = fsdata; 1905 struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data; 1906 handle_t *handle = wc->w_handle; 1907 struct page *tmppage; 1908 1909 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 1910 ocfs2_write_end_inline(inode, pos, len, &copied, di, wc); 1911 goto out_write_size; 1912 } 1913 1914 if (unlikely(copied < len)) { 1915 if (!PageUptodate(wc->w_target_page)) 1916 copied = 0; 1917 1918 ocfs2_zero_new_buffers(wc->w_target_page, start+copied, 1919 start+len); 1920 } 1921 flush_dcache_page(wc->w_target_page); 1922 1923 for(i = 0; i < wc->w_num_pages; i++) { 1924 tmppage = wc->w_pages[i]; 1925 1926 if (tmppage == wc->w_target_page) { 1927 from = wc->w_target_from; 1928 to = wc->w_target_to; 1929 1930 BUG_ON(from > PAGE_CACHE_SIZE || 1931 to > PAGE_CACHE_SIZE || 1932 to < from); 1933 } else { 1934 /* 1935 * Pages adjacent to the target (if any) imply 1936 * a hole-filling write in which case we want 1937 * to flush their entire range. 1938 */ 1939 from = 0; 1940 to = PAGE_CACHE_SIZE; 1941 } 1942 1943 if (page_has_buffers(tmppage)) { 1944 if (ocfs2_should_order_data(inode)) 1945 ocfs2_jbd2_file_inode(wc->w_handle, inode); 1946 block_commit_write(tmppage, from, to); 1947 } 1948 } 1949 1950out_write_size: 1951 pos += copied; 1952 if (pos > inode->i_size) { 1953 i_size_write(inode, pos); 1954 mark_inode_dirty(inode); 1955 } 1956 inode->i_blocks = ocfs2_inode_sector_count(inode); 1957 di->i_size = cpu_to_le64((u64)i_size_read(inode)); 1958 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 1959 di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec); 1960 di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); 1961 ocfs2_journal_dirty(handle, wc->w_di_bh); 1962 1963 ocfs2_commit_trans(osb, handle); 1964 1965 ocfs2_run_deallocs(osb, &wc->w_dealloc); 1966 1967 ocfs2_free_write_ctxt(wc); 1968 1969 return copied; 1970} 1971 1972static int ocfs2_write_end(struct file *file, struct address_space *mapping, 1973 loff_t pos, unsigned len, unsigned copied, 1974 struct page *page, void *fsdata) 1975{ 1976 int ret; 1977 struct inode *inode = mapping->host; 1978 1979 ret = ocfs2_write_end_nolock(mapping, pos, len, copied, page, fsdata); 1980 1981 up_write(&OCFS2_I(inode)->ip_alloc_sem); 1982 ocfs2_inode_unlock(inode, 1); 1983 1984 return ret; 1985} 1986 1987const struct address_space_operations ocfs2_aops = { 1988 .readpage = ocfs2_readpage, 1989 .readpages = ocfs2_readpages, 1990 .writepage = ocfs2_writepage, 1991 .write_begin = ocfs2_write_begin, 1992 .write_end = ocfs2_write_end, 1993 .bmap = ocfs2_bmap, 1994 .sync_page = block_sync_page, 1995 .direct_IO = ocfs2_direct_IO, 1996 .invalidatepage = ocfs2_invalidatepage, 1997 .releasepage = ocfs2_releasepage, 1998 .migratepage = buffer_migrate_page, 1999 .is_partially_uptodate = block_is_partially_uptodate, 2000}; 2001