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