1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * file.c 5 * 6 * File open, close, extend, truncate 7 * 8 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public 12 * License as published by the Free Software Foundation; either 13 * version 2 of the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public 21 * License along with this program; if not, write to the 22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23 * Boston, MA 021110-1307, USA. 24 */ 25 26 #include <linux/capability.h> 27 #include <linux/fs.h> 28 #include <linux/types.h> 29 #include <linux/slab.h> 30 #include <linux/highmem.h> 31 #include <linux/pagemap.h> 32 #include <linux/uio.h> 33 #include <linux/sched.h> 34 #include <linux/splice.h> 35 #include <linux/mount.h> 36 #include <linux/writeback.h> 37 #include <linux/falloc.h> 38 #include <linux/quotaops.h> 39 #include <linux/blkdev.h> 40 41 #include <cluster/masklog.h> 42 43 #include "ocfs2.h" 44 45 #include "alloc.h" 46 #include "aops.h" 47 #include "dir.h" 48 #include "dlmglue.h" 49 #include "extent_map.h" 50 #include "file.h" 51 #include "sysfile.h" 52 #include "inode.h" 53 #include "ioctl.h" 54 #include "journal.h" 55 #include "locks.h" 56 #include "mmap.h" 57 #include "suballoc.h" 58 #include "super.h" 59 #include "xattr.h" 60 #include "acl.h" 61 #include "quota.h" 62 #include "refcounttree.h" 63 #include "ocfs2_trace.h" 64 65 #include "buffer_head_io.h" 66 67 static int ocfs2_init_file_private(struct inode *inode, struct file *file) 68 { 69 struct ocfs2_file_private *fp; 70 71 fp = kzalloc(sizeof(struct ocfs2_file_private), GFP_KERNEL); 72 if (!fp) 73 return -ENOMEM; 74 75 fp->fp_file = file; 76 mutex_init(&fp->fp_mutex); 77 ocfs2_file_lock_res_init(&fp->fp_flock, fp); 78 file->private_data = fp; 79 80 return 0; 81 } 82 83 static void ocfs2_free_file_private(struct inode *inode, struct file *file) 84 { 85 struct ocfs2_file_private *fp = file->private_data; 86 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 87 88 if (fp) { 89 ocfs2_simple_drop_lockres(osb, &fp->fp_flock); 90 ocfs2_lock_res_free(&fp->fp_flock); 91 kfree(fp); 92 file->private_data = NULL; 93 } 94 } 95 96 static int ocfs2_file_open(struct inode *inode, struct file *file) 97 { 98 int status; 99 int mode = file->f_flags; 100 struct ocfs2_inode_info *oi = OCFS2_I(inode); 101 102 trace_ocfs2_file_open(inode, file, file->f_path.dentry, 103 (unsigned long long)OCFS2_I(inode)->ip_blkno, 104 file->f_path.dentry->d_name.len, 105 file->f_path.dentry->d_name.name, mode); 106 107 if (file->f_mode & FMODE_WRITE) 108 dquot_initialize(inode); 109 110 spin_lock(&oi->ip_lock); 111 112 /* Check that the inode hasn't been wiped from disk by another 113 * node. If it hasn't then we're safe as long as we hold the 114 * spin lock until our increment of open count. */ 115 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) { 116 spin_unlock(&oi->ip_lock); 117 118 status = -ENOENT; 119 goto leave; 120 } 121 122 if (mode & O_DIRECT) 123 oi->ip_flags |= OCFS2_INODE_OPEN_DIRECT; 124 125 oi->ip_open_count++; 126 spin_unlock(&oi->ip_lock); 127 128 status = ocfs2_init_file_private(inode, file); 129 if (status) { 130 /* 131 * We want to set open count back if we're failing the 132 * open. 133 */ 134 spin_lock(&oi->ip_lock); 135 oi->ip_open_count--; 136 spin_unlock(&oi->ip_lock); 137 } 138 139 leave: 140 return status; 141 } 142 143 static int ocfs2_file_release(struct inode *inode, struct file *file) 144 { 145 struct ocfs2_inode_info *oi = OCFS2_I(inode); 146 147 spin_lock(&oi->ip_lock); 148 if (!--oi->ip_open_count) 149 oi->ip_flags &= ~OCFS2_INODE_OPEN_DIRECT; 150 151 trace_ocfs2_file_release(inode, file, file->f_path.dentry, 152 oi->ip_blkno, 153 file->f_path.dentry->d_name.len, 154 file->f_path.dentry->d_name.name, 155 oi->ip_open_count); 156 spin_unlock(&oi->ip_lock); 157 158 ocfs2_free_file_private(inode, file); 159 160 return 0; 161 } 162 163 static int ocfs2_dir_open(struct inode *inode, struct file *file) 164 { 165 return ocfs2_init_file_private(inode, file); 166 } 167 168 static int ocfs2_dir_release(struct inode *inode, struct file *file) 169 { 170 ocfs2_free_file_private(inode, file); 171 return 0; 172 } 173 174 static int ocfs2_sync_file(struct file *file, loff_t start, loff_t end, 175 int datasync) 176 { 177 int err = 0; 178 journal_t *journal; 179 struct inode *inode = file->f_mapping->host; 180 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 181 182 trace_ocfs2_sync_file(inode, file, file->f_path.dentry, 183 OCFS2_I(inode)->ip_blkno, 184 file->f_path.dentry->d_name.len, 185 file->f_path.dentry->d_name.name, 186 (unsigned long long)datasync); 187 188 err = filemap_write_and_wait_range(inode->i_mapping, start, end); 189 if (err) 190 return err; 191 192 /* 193 * Probably don't need the i_mutex at all in here, just putting it here 194 * to be consistent with how fsync used to be called, someone more 195 * familiar with the fs could possibly remove it. 196 */ 197 mutex_lock(&inode->i_mutex); 198 if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) { 199 /* 200 * We still have to flush drive's caches to get data to the 201 * platter 202 */ 203 if (osb->s_mount_opt & OCFS2_MOUNT_BARRIER) 204 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); 205 goto bail; 206 } 207 208 journal = osb->journal->j_journal; 209 err = jbd2_journal_force_commit(journal); 210 211 bail: 212 if (err) 213 mlog_errno(err); 214 mutex_unlock(&inode->i_mutex); 215 216 return (err < 0) ? -EIO : 0; 217 } 218 219 int ocfs2_should_update_atime(struct inode *inode, 220 struct vfsmount *vfsmnt) 221 { 222 struct timespec now; 223 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 224 225 if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb)) 226 return 0; 227 228 if ((inode->i_flags & S_NOATIME) || 229 ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))) 230 return 0; 231 232 /* 233 * We can be called with no vfsmnt structure - NFSD will 234 * sometimes do this. 235 * 236 * Note that our action here is different than touch_atime() - 237 * if we can't tell whether this is a noatime mount, then we 238 * don't know whether to trust the value of s_atime_quantum. 239 */ 240 if (vfsmnt == NULL) 241 return 0; 242 243 if ((vfsmnt->mnt_flags & MNT_NOATIME) || 244 ((vfsmnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) 245 return 0; 246 247 if (vfsmnt->mnt_flags & MNT_RELATIME) { 248 if ((timespec_compare(&inode->i_atime, &inode->i_mtime) <= 0) || 249 (timespec_compare(&inode->i_atime, &inode->i_ctime) <= 0)) 250 return 1; 251 252 return 0; 253 } 254 255 now = CURRENT_TIME; 256 if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum)) 257 return 0; 258 else 259 return 1; 260 } 261 262 int ocfs2_update_inode_atime(struct inode *inode, 263 struct buffer_head *bh) 264 { 265 int ret; 266 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 267 handle_t *handle; 268 struct ocfs2_dinode *di = (struct ocfs2_dinode *) bh->b_data; 269 270 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 271 if (IS_ERR(handle)) { 272 ret = PTR_ERR(handle); 273 mlog_errno(ret); 274 goto out; 275 } 276 277 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh, 278 OCFS2_JOURNAL_ACCESS_WRITE); 279 if (ret) { 280 mlog_errno(ret); 281 goto out_commit; 282 } 283 284 /* 285 * Don't use ocfs2_mark_inode_dirty() here as we don't always 286 * have i_mutex to guard against concurrent changes to other 287 * inode fields. 288 */ 289 inode->i_atime = CURRENT_TIME; 290 di->i_atime = cpu_to_le64(inode->i_atime.tv_sec); 291 di->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec); 292 ocfs2_journal_dirty(handle, bh); 293 294 out_commit: 295 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 296 out: 297 return ret; 298 } 299 300 static int ocfs2_set_inode_size(handle_t *handle, 301 struct inode *inode, 302 struct buffer_head *fe_bh, 303 u64 new_i_size) 304 { 305 int status; 306 307 i_size_write(inode, new_i_size); 308 inode->i_blocks = ocfs2_inode_sector_count(inode); 309 inode->i_ctime = inode->i_mtime = CURRENT_TIME; 310 311 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh); 312 if (status < 0) { 313 mlog_errno(status); 314 goto bail; 315 } 316 317 bail: 318 return status; 319 } 320 321 int ocfs2_simple_size_update(struct inode *inode, 322 struct buffer_head *di_bh, 323 u64 new_i_size) 324 { 325 int ret; 326 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 327 handle_t *handle = NULL; 328 329 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 330 if (IS_ERR(handle)) { 331 ret = PTR_ERR(handle); 332 mlog_errno(ret); 333 goto out; 334 } 335 336 ret = ocfs2_set_inode_size(handle, inode, di_bh, 337 new_i_size); 338 if (ret < 0) 339 mlog_errno(ret); 340 341 ocfs2_commit_trans(osb, handle); 342 out: 343 return ret; 344 } 345 346 static int ocfs2_cow_file_pos(struct inode *inode, 347 struct buffer_head *fe_bh, 348 u64 offset) 349 { 350 int status; 351 u32 phys, cpos = offset >> OCFS2_SB(inode->i_sb)->s_clustersize_bits; 352 unsigned int num_clusters = 0; 353 unsigned int ext_flags = 0; 354 355 /* 356 * If the new offset is aligned to the range of the cluster, there is 357 * no space for ocfs2_zero_range_for_truncate to fill, so no need to 358 * CoW either. 359 */ 360 if ((offset & (OCFS2_SB(inode->i_sb)->s_clustersize - 1)) == 0) 361 return 0; 362 363 status = ocfs2_get_clusters(inode, cpos, &phys, 364 &num_clusters, &ext_flags); 365 if (status) { 366 mlog_errno(status); 367 goto out; 368 } 369 370 if (!(ext_flags & OCFS2_EXT_REFCOUNTED)) 371 goto out; 372 373 return ocfs2_refcount_cow(inode, NULL, fe_bh, cpos, 1, cpos+1); 374 375 out: 376 return status; 377 } 378 379 static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb, 380 struct inode *inode, 381 struct buffer_head *fe_bh, 382 u64 new_i_size) 383 { 384 int status; 385 handle_t *handle; 386 struct ocfs2_dinode *di; 387 u64 cluster_bytes; 388 389 /* 390 * We need to CoW the cluster contains the offset if it is reflinked 391 * since we will call ocfs2_zero_range_for_truncate later which will 392 * write "0" from offset to the end of the cluster. 393 */ 394 status = ocfs2_cow_file_pos(inode, fe_bh, new_i_size); 395 if (status) { 396 mlog_errno(status); 397 return status; 398 } 399 400 /* TODO: This needs to actually orphan the inode in this 401 * transaction. */ 402 403 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 404 if (IS_ERR(handle)) { 405 status = PTR_ERR(handle); 406 mlog_errno(status); 407 goto out; 408 } 409 410 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh, 411 OCFS2_JOURNAL_ACCESS_WRITE); 412 if (status < 0) { 413 mlog_errno(status); 414 goto out_commit; 415 } 416 417 /* 418 * Do this before setting i_size. 419 */ 420 cluster_bytes = ocfs2_align_bytes_to_clusters(inode->i_sb, new_i_size); 421 status = ocfs2_zero_range_for_truncate(inode, handle, new_i_size, 422 cluster_bytes); 423 if (status) { 424 mlog_errno(status); 425 goto out_commit; 426 } 427 428 i_size_write(inode, new_i_size); 429 inode->i_ctime = inode->i_mtime = CURRENT_TIME; 430 431 di = (struct ocfs2_dinode *) fe_bh->b_data; 432 di->i_size = cpu_to_le64(new_i_size); 433 di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec); 434 di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 435 436 ocfs2_journal_dirty(handle, fe_bh); 437 438 out_commit: 439 ocfs2_commit_trans(osb, handle); 440 out: 441 return status; 442 } 443 444 static int ocfs2_truncate_file(struct inode *inode, 445 struct buffer_head *di_bh, 446 u64 new_i_size) 447 { 448 int status = 0; 449 struct ocfs2_dinode *fe = NULL; 450 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 451 452 /* We trust di_bh because it comes from ocfs2_inode_lock(), which 453 * already validated it */ 454 fe = (struct ocfs2_dinode *) di_bh->b_data; 455 456 trace_ocfs2_truncate_file((unsigned long long)OCFS2_I(inode)->ip_blkno, 457 (unsigned long long)le64_to_cpu(fe->i_size), 458 (unsigned long long)new_i_size); 459 460 mlog_bug_on_msg(le64_to_cpu(fe->i_size) != i_size_read(inode), 461 "Inode %llu, inode i_size = %lld != di " 462 "i_size = %llu, i_flags = 0x%x\n", 463 (unsigned long long)OCFS2_I(inode)->ip_blkno, 464 i_size_read(inode), 465 (unsigned long long)le64_to_cpu(fe->i_size), 466 le32_to_cpu(fe->i_flags)); 467 468 if (new_i_size > le64_to_cpu(fe->i_size)) { 469 trace_ocfs2_truncate_file_error( 470 (unsigned long long)le64_to_cpu(fe->i_size), 471 (unsigned long long)new_i_size); 472 status = -EINVAL; 473 mlog_errno(status); 474 goto bail; 475 } 476 477 /* lets handle the simple truncate cases before doing any more 478 * cluster locking. */ 479 if (new_i_size == le64_to_cpu(fe->i_size)) 480 goto bail; 481 482 down_write(&OCFS2_I(inode)->ip_alloc_sem); 483 484 ocfs2_resv_discard(&osb->osb_la_resmap, 485 &OCFS2_I(inode)->ip_la_data_resv); 486 487 /* 488 * The inode lock forced other nodes to sync and drop their 489 * pages, which (correctly) happens even if we have a truncate 490 * without allocation change - ocfs2 cluster sizes can be much 491 * greater than page size, so we have to truncate them 492 * anyway. 493 */ 494 unmap_mapping_range(inode->i_mapping, new_i_size + PAGE_SIZE - 1, 0, 1); 495 truncate_inode_pages(inode->i_mapping, new_i_size); 496 497 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 498 status = ocfs2_truncate_inline(inode, di_bh, new_i_size, 499 i_size_read(inode), 1); 500 if (status) 501 mlog_errno(status); 502 503 goto bail_unlock_sem; 504 } 505 506 /* alright, we're going to need to do a full blown alloc size 507 * change. Orphan the inode so that recovery can complete the 508 * truncate if necessary. This does the task of marking 509 * i_size. */ 510 status = ocfs2_orphan_for_truncate(osb, inode, di_bh, new_i_size); 511 if (status < 0) { 512 mlog_errno(status); 513 goto bail_unlock_sem; 514 } 515 516 status = ocfs2_commit_truncate(osb, inode, di_bh); 517 if (status < 0) { 518 mlog_errno(status); 519 goto bail_unlock_sem; 520 } 521 522 /* TODO: orphan dir cleanup here. */ 523 bail_unlock_sem: 524 up_write(&OCFS2_I(inode)->ip_alloc_sem); 525 526 bail: 527 if (!status && OCFS2_I(inode)->ip_clusters == 0) 528 status = ocfs2_try_remove_refcount_tree(inode, di_bh); 529 530 return status; 531 } 532 533 /* 534 * extend file allocation only here. 535 * we'll update all the disk stuff, and oip->alloc_size 536 * 537 * expect stuff to be locked, a transaction started and enough data / 538 * metadata reservations in the contexts. 539 * 540 * Will return -EAGAIN, and a reason if a restart is needed. 541 * If passed in, *reason will always be set, even in error. 542 */ 543 int ocfs2_add_inode_data(struct ocfs2_super *osb, 544 struct inode *inode, 545 u32 *logical_offset, 546 u32 clusters_to_add, 547 int mark_unwritten, 548 struct buffer_head *fe_bh, 549 handle_t *handle, 550 struct ocfs2_alloc_context *data_ac, 551 struct ocfs2_alloc_context *meta_ac, 552 enum ocfs2_alloc_restarted *reason_ret) 553 { 554 int ret; 555 struct ocfs2_extent_tree et; 556 557 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), fe_bh); 558 ret = ocfs2_add_clusters_in_btree(handle, &et, logical_offset, 559 clusters_to_add, mark_unwritten, 560 data_ac, meta_ac, reason_ret); 561 562 return ret; 563 } 564 565 static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start, 566 u32 clusters_to_add, int mark_unwritten) 567 { 568 int status = 0; 569 int restart_func = 0; 570 int credits; 571 u32 prev_clusters; 572 struct buffer_head *bh = NULL; 573 struct ocfs2_dinode *fe = NULL; 574 handle_t *handle = NULL; 575 struct ocfs2_alloc_context *data_ac = NULL; 576 struct ocfs2_alloc_context *meta_ac = NULL; 577 enum ocfs2_alloc_restarted why; 578 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 579 struct ocfs2_extent_tree et; 580 int did_quota = 0; 581 582 /* 583 * This function only exists for file systems which don't 584 * support holes. 585 */ 586 BUG_ON(mark_unwritten && !ocfs2_sparse_alloc(osb)); 587 588 status = ocfs2_read_inode_block(inode, &bh); 589 if (status < 0) { 590 mlog_errno(status); 591 goto leave; 592 } 593 fe = (struct ocfs2_dinode *) bh->b_data; 594 595 restart_all: 596 BUG_ON(le32_to_cpu(fe->i_clusters) != OCFS2_I(inode)->ip_clusters); 597 598 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), bh); 599 status = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0, 600 &data_ac, &meta_ac); 601 if (status) { 602 mlog_errno(status); 603 goto leave; 604 } 605 606 credits = ocfs2_calc_extend_credits(osb->sb, &fe->id2.i_list, 607 clusters_to_add); 608 handle = ocfs2_start_trans(osb, credits); 609 if (IS_ERR(handle)) { 610 status = PTR_ERR(handle); 611 handle = NULL; 612 mlog_errno(status); 613 goto leave; 614 } 615 616 restarted_transaction: 617 trace_ocfs2_extend_allocation( 618 (unsigned long long)OCFS2_I(inode)->ip_blkno, 619 (unsigned long long)i_size_read(inode), 620 le32_to_cpu(fe->i_clusters), clusters_to_add, 621 why, restart_func); 622 623 status = dquot_alloc_space_nodirty(inode, 624 ocfs2_clusters_to_bytes(osb->sb, clusters_to_add)); 625 if (status) 626 goto leave; 627 did_quota = 1; 628 629 /* reserve a write to the file entry early on - that we if we 630 * run out of credits in the allocation path, we can still 631 * update i_size. */ 632 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh, 633 OCFS2_JOURNAL_ACCESS_WRITE); 634 if (status < 0) { 635 mlog_errno(status); 636 goto leave; 637 } 638 639 prev_clusters = OCFS2_I(inode)->ip_clusters; 640 641 status = ocfs2_add_inode_data(osb, 642 inode, 643 &logical_start, 644 clusters_to_add, 645 mark_unwritten, 646 bh, 647 handle, 648 data_ac, 649 meta_ac, 650 &why); 651 if ((status < 0) && (status != -EAGAIN)) { 652 if (status != -ENOSPC) 653 mlog_errno(status); 654 goto leave; 655 } 656 657 ocfs2_journal_dirty(handle, bh); 658 659 spin_lock(&OCFS2_I(inode)->ip_lock); 660 clusters_to_add -= (OCFS2_I(inode)->ip_clusters - prev_clusters); 661 spin_unlock(&OCFS2_I(inode)->ip_lock); 662 /* Release unused quota reservation */ 663 dquot_free_space(inode, 664 ocfs2_clusters_to_bytes(osb->sb, clusters_to_add)); 665 did_quota = 0; 666 667 if (why != RESTART_NONE && clusters_to_add) { 668 if (why == RESTART_META) { 669 restart_func = 1; 670 status = 0; 671 } else { 672 BUG_ON(why != RESTART_TRANS); 673 674 /* TODO: This can be more intelligent. */ 675 credits = ocfs2_calc_extend_credits(osb->sb, 676 &fe->id2.i_list, 677 clusters_to_add); 678 status = ocfs2_extend_trans(handle, credits); 679 if (status < 0) { 680 /* handle still has to be committed at 681 * this point. */ 682 status = -ENOMEM; 683 mlog_errno(status); 684 goto leave; 685 } 686 goto restarted_transaction; 687 } 688 } 689 690 trace_ocfs2_extend_allocation_end(OCFS2_I(inode)->ip_blkno, 691 le32_to_cpu(fe->i_clusters), 692 (unsigned long long)le64_to_cpu(fe->i_size), 693 OCFS2_I(inode)->ip_clusters, 694 (unsigned long long)i_size_read(inode)); 695 696 leave: 697 if (status < 0 && did_quota) 698 dquot_free_space(inode, 699 ocfs2_clusters_to_bytes(osb->sb, clusters_to_add)); 700 if (handle) { 701 ocfs2_commit_trans(osb, handle); 702 handle = NULL; 703 } 704 if (data_ac) { 705 ocfs2_free_alloc_context(data_ac); 706 data_ac = NULL; 707 } 708 if (meta_ac) { 709 ocfs2_free_alloc_context(meta_ac); 710 meta_ac = NULL; 711 } 712 if ((!status) && restart_func) { 713 restart_func = 0; 714 goto restart_all; 715 } 716 brelse(bh); 717 bh = NULL; 718 719 return status; 720 } 721 722 /* 723 * While a write will already be ordering the data, a truncate will not. 724 * Thus, we need to explicitly order the zeroed pages. 725 */ 726 static handle_t *ocfs2_zero_start_ordered_transaction(struct inode *inode) 727 { 728 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 729 handle_t *handle = NULL; 730 int ret = 0; 731 732 if (!ocfs2_should_order_data(inode)) 733 goto out; 734 735 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 736 if (IS_ERR(handle)) { 737 ret = -ENOMEM; 738 mlog_errno(ret); 739 goto out; 740 } 741 742 ret = ocfs2_jbd2_file_inode(handle, inode); 743 if (ret < 0) 744 mlog_errno(ret); 745 746 out: 747 if (ret) { 748 if (!IS_ERR(handle)) 749 ocfs2_commit_trans(osb, handle); 750 handle = ERR_PTR(ret); 751 } 752 return handle; 753 } 754 755 /* Some parts of this taken from generic_cont_expand, which turned out 756 * to be too fragile to do exactly what we need without us having to 757 * worry about recursive locking in ->write_begin() and ->write_end(). */ 758 static int ocfs2_write_zero_page(struct inode *inode, u64 abs_from, 759 u64 abs_to) 760 { 761 struct address_space *mapping = inode->i_mapping; 762 struct page *page; 763 unsigned long index = abs_from >> PAGE_CACHE_SHIFT; 764 handle_t *handle = NULL; 765 int ret = 0; 766 unsigned zero_from, zero_to, block_start, block_end; 767 768 BUG_ON(abs_from >= abs_to); 769 BUG_ON(abs_to > (((u64)index + 1) << PAGE_CACHE_SHIFT)); 770 BUG_ON(abs_from & (inode->i_blkbits - 1)); 771 772 page = find_or_create_page(mapping, index, GFP_NOFS); 773 if (!page) { 774 ret = -ENOMEM; 775 mlog_errno(ret); 776 goto out; 777 } 778 779 /* Get the offsets within the page that we want to zero */ 780 zero_from = abs_from & (PAGE_CACHE_SIZE - 1); 781 zero_to = abs_to & (PAGE_CACHE_SIZE - 1); 782 if (!zero_to) 783 zero_to = PAGE_CACHE_SIZE; 784 785 trace_ocfs2_write_zero_page( 786 (unsigned long long)OCFS2_I(inode)->ip_blkno, 787 (unsigned long long)abs_from, 788 (unsigned long long)abs_to, 789 index, zero_from, zero_to); 790 791 /* We know that zero_from is block aligned */ 792 for (block_start = zero_from; block_start < zero_to; 793 block_start = block_end) { 794 block_end = block_start + (1 << inode->i_blkbits); 795 796 /* 797 * block_start is block-aligned. Bump it by one to force 798 * __block_write_begin and block_commit_write to zero the 799 * whole block. 800 */ 801 ret = __block_write_begin(page, block_start + 1, 0, 802 ocfs2_get_block); 803 if (ret < 0) { 804 mlog_errno(ret); 805 goto out_unlock; 806 } 807 808 if (!handle) { 809 handle = ocfs2_zero_start_ordered_transaction(inode); 810 if (IS_ERR(handle)) { 811 ret = PTR_ERR(handle); 812 handle = NULL; 813 break; 814 } 815 } 816 817 /* must not update i_size! */ 818 ret = block_commit_write(page, block_start + 1, 819 block_start + 1); 820 if (ret < 0) 821 mlog_errno(ret); 822 else 823 ret = 0; 824 } 825 826 if (handle) 827 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 828 829 out_unlock: 830 unlock_page(page); 831 page_cache_release(page); 832 out: 833 return ret; 834 } 835 836 /* 837 * Find the next range to zero. We do this in terms of bytes because 838 * that's what ocfs2_zero_extend() wants, and it is dealing with the 839 * pagecache. We may return multiple extents. 840 * 841 * zero_start and zero_end are ocfs2_zero_extend()s current idea of what 842 * needs to be zeroed. range_start and range_end return the next zeroing 843 * range. A subsequent call should pass the previous range_end as its 844 * zero_start. If range_end is 0, there's nothing to do. 845 * 846 * Unwritten extents are skipped over. Refcounted extents are CoWd. 847 */ 848 static int ocfs2_zero_extend_get_range(struct inode *inode, 849 struct buffer_head *di_bh, 850 u64 zero_start, u64 zero_end, 851 u64 *range_start, u64 *range_end) 852 { 853 int rc = 0, needs_cow = 0; 854 u32 p_cpos, zero_clusters = 0; 855 u32 zero_cpos = 856 zero_start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits; 857 u32 last_cpos = ocfs2_clusters_for_bytes(inode->i_sb, zero_end); 858 unsigned int num_clusters = 0; 859 unsigned int ext_flags = 0; 860 861 while (zero_cpos < last_cpos) { 862 rc = ocfs2_get_clusters(inode, zero_cpos, &p_cpos, 863 &num_clusters, &ext_flags); 864 if (rc) { 865 mlog_errno(rc); 866 goto out; 867 } 868 869 if (p_cpos && !(ext_flags & OCFS2_EXT_UNWRITTEN)) { 870 zero_clusters = num_clusters; 871 if (ext_flags & OCFS2_EXT_REFCOUNTED) 872 needs_cow = 1; 873 break; 874 } 875 876 zero_cpos += num_clusters; 877 } 878 if (!zero_clusters) { 879 *range_end = 0; 880 goto out; 881 } 882 883 while ((zero_cpos + zero_clusters) < last_cpos) { 884 rc = ocfs2_get_clusters(inode, zero_cpos + zero_clusters, 885 &p_cpos, &num_clusters, 886 &ext_flags); 887 if (rc) { 888 mlog_errno(rc); 889 goto out; 890 } 891 892 if (!p_cpos || (ext_flags & OCFS2_EXT_UNWRITTEN)) 893 break; 894 if (ext_flags & OCFS2_EXT_REFCOUNTED) 895 needs_cow = 1; 896 zero_clusters += num_clusters; 897 } 898 if ((zero_cpos + zero_clusters) > last_cpos) 899 zero_clusters = last_cpos - zero_cpos; 900 901 if (needs_cow) { 902 rc = ocfs2_refcount_cow(inode, NULL, di_bh, zero_cpos, 903 zero_clusters, UINT_MAX); 904 if (rc) { 905 mlog_errno(rc); 906 goto out; 907 } 908 } 909 910 *range_start = ocfs2_clusters_to_bytes(inode->i_sb, zero_cpos); 911 *range_end = ocfs2_clusters_to_bytes(inode->i_sb, 912 zero_cpos + zero_clusters); 913 914 out: 915 return rc; 916 } 917 918 /* 919 * Zero one range returned from ocfs2_zero_extend_get_range(). The caller 920 * has made sure that the entire range needs zeroing. 921 */ 922 static int ocfs2_zero_extend_range(struct inode *inode, u64 range_start, 923 u64 range_end) 924 { 925 int rc = 0; 926 u64 next_pos; 927 u64 zero_pos = range_start; 928 929 trace_ocfs2_zero_extend_range( 930 (unsigned long long)OCFS2_I(inode)->ip_blkno, 931 (unsigned long long)range_start, 932 (unsigned long long)range_end); 933 BUG_ON(range_start >= range_end); 934 935 while (zero_pos < range_end) { 936 next_pos = (zero_pos & PAGE_CACHE_MASK) + PAGE_CACHE_SIZE; 937 if (next_pos > range_end) 938 next_pos = range_end; 939 rc = ocfs2_write_zero_page(inode, zero_pos, next_pos); 940 if (rc < 0) { 941 mlog_errno(rc); 942 break; 943 } 944 zero_pos = next_pos; 945 946 /* 947 * Very large extends have the potential to lock up 948 * the cpu for extended periods of time. 949 */ 950 cond_resched(); 951 } 952 953 return rc; 954 } 955 956 int ocfs2_zero_extend(struct inode *inode, struct buffer_head *di_bh, 957 loff_t zero_to_size) 958 { 959 int ret = 0; 960 u64 zero_start, range_start = 0, range_end = 0; 961 struct super_block *sb = inode->i_sb; 962 963 zero_start = ocfs2_align_bytes_to_blocks(sb, i_size_read(inode)); 964 trace_ocfs2_zero_extend((unsigned long long)OCFS2_I(inode)->ip_blkno, 965 (unsigned long long)zero_start, 966 (unsigned long long)i_size_read(inode)); 967 while (zero_start < zero_to_size) { 968 ret = ocfs2_zero_extend_get_range(inode, di_bh, zero_start, 969 zero_to_size, 970 &range_start, 971 &range_end); 972 if (ret) { 973 mlog_errno(ret); 974 break; 975 } 976 if (!range_end) 977 break; 978 /* Trim the ends */ 979 if (range_start < zero_start) 980 range_start = zero_start; 981 if (range_end > zero_to_size) 982 range_end = zero_to_size; 983 984 ret = ocfs2_zero_extend_range(inode, range_start, 985 range_end); 986 if (ret) { 987 mlog_errno(ret); 988 break; 989 } 990 zero_start = range_end; 991 } 992 993 return ret; 994 } 995 996 int ocfs2_extend_no_holes(struct inode *inode, struct buffer_head *di_bh, 997 u64 new_i_size, u64 zero_to) 998 { 999 int ret; 1000 u32 clusters_to_add; 1001 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1002 1003 /* 1004 * Only quota files call this without a bh, and they can't be 1005 * refcounted. 1006 */ 1007 BUG_ON(!di_bh && (oi->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL)); 1008 BUG_ON(!di_bh && !(oi->ip_flags & OCFS2_INODE_SYSTEM_FILE)); 1009 1010 clusters_to_add = ocfs2_clusters_for_bytes(inode->i_sb, new_i_size); 1011 if (clusters_to_add < oi->ip_clusters) 1012 clusters_to_add = 0; 1013 else 1014 clusters_to_add -= oi->ip_clusters; 1015 1016 if (clusters_to_add) { 1017 ret = __ocfs2_extend_allocation(inode, oi->ip_clusters, 1018 clusters_to_add, 0); 1019 if (ret) { 1020 mlog_errno(ret); 1021 goto out; 1022 } 1023 } 1024 1025 /* 1026 * Call this even if we don't add any clusters to the tree. We 1027 * still need to zero the area between the old i_size and the 1028 * new i_size. 1029 */ 1030 ret = ocfs2_zero_extend(inode, di_bh, zero_to); 1031 if (ret < 0) 1032 mlog_errno(ret); 1033 1034 out: 1035 return ret; 1036 } 1037 1038 static int ocfs2_extend_file(struct inode *inode, 1039 struct buffer_head *di_bh, 1040 u64 new_i_size) 1041 { 1042 int ret = 0; 1043 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1044 1045 BUG_ON(!di_bh); 1046 1047 /* setattr sometimes calls us like this. */ 1048 if (new_i_size == 0) 1049 goto out; 1050 1051 if (i_size_read(inode) == new_i_size) 1052 goto out; 1053 BUG_ON(new_i_size < i_size_read(inode)); 1054 1055 /* 1056 * The alloc sem blocks people in read/write from reading our 1057 * allocation until we're done changing it. We depend on 1058 * i_mutex to block other extend/truncate calls while we're 1059 * here. We even have to hold it for sparse files because there 1060 * might be some tail zeroing. 1061 */ 1062 down_write(&oi->ip_alloc_sem); 1063 1064 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 1065 /* 1066 * We can optimize small extends by keeping the inodes 1067 * inline data. 1068 */ 1069 if (ocfs2_size_fits_inline_data(di_bh, new_i_size)) { 1070 up_write(&oi->ip_alloc_sem); 1071 goto out_update_size; 1072 } 1073 1074 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh); 1075 if (ret) { 1076 up_write(&oi->ip_alloc_sem); 1077 mlog_errno(ret); 1078 goto out; 1079 } 1080 } 1081 1082 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))) 1083 ret = ocfs2_zero_extend(inode, di_bh, new_i_size); 1084 else 1085 ret = ocfs2_extend_no_holes(inode, di_bh, new_i_size, 1086 new_i_size); 1087 1088 up_write(&oi->ip_alloc_sem); 1089 1090 if (ret < 0) { 1091 mlog_errno(ret); 1092 goto out; 1093 } 1094 1095 out_update_size: 1096 ret = ocfs2_simple_size_update(inode, di_bh, new_i_size); 1097 if (ret < 0) 1098 mlog_errno(ret); 1099 1100 out: 1101 return ret; 1102 } 1103 1104 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr) 1105 { 1106 int status = 0, size_change; 1107 struct inode *inode = dentry->d_inode; 1108 struct super_block *sb = inode->i_sb; 1109 struct ocfs2_super *osb = OCFS2_SB(sb); 1110 struct buffer_head *bh = NULL; 1111 handle_t *handle = NULL; 1112 struct dquot *transfer_to[MAXQUOTAS] = { }; 1113 int qtype; 1114 1115 trace_ocfs2_setattr(inode, dentry, 1116 (unsigned long long)OCFS2_I(inode)->ip_blkno, 1117 dentry->d_name.len, dentry->d_name.name, 1118 attr->ia_valid, attr->ia_mode, 1119 attr->ia_uid, attr->ia_gid); 1120 1121 /* ensuring we don't even attempt to truncate a symlink */ 1122 if (S_ISLNK(inode->i_mode)) 1123 attr->ia_valid &= ~ATTR_SIZE; 1124 1125 #define OCFS2_VALID_ATTRS (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME | ATTR_SIZE \ 1126 | ATTR_GID | ATTR_UID | ATTR_MODE) 1127 if (!(attr->ia_valid & OCFS2_VALID_ATTRS)) 1128 return 0; 1129 1130 status = inode_change_ok(inode, attr); 1131 if (status) 1132 return status; 1133 1134 if (is_quota_modification(inode, attr)) 1135 dquot_initialize(inode); 1136 size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE; 1137 if (size_change) { 1138 status = ocfs2_rw_lock(inode, 1); 1139 if (status < 0) { 1140 mlog_errno(status); 1141 goto bail; 1142 } 1143 } 1144 1145 status = ocfs2_inode_lock(inode, &bh, 1); 1146 if (status < 0) { 1147 if (status != -ENOENT) 1148 mlog_errno(status); 1149 goto bail_unlock_rw; 1150 } 1151 1152 if (size_change && attr->ia_size != i_size_read(inode)) { 1153 status = inode_newsize_ok(inode, attr->ia_size); 1154 if (status) 1155 goto bail_unlock; 1156 1157 inode_dio_wait(inode); 1158 1159 if (i_size_read(inode) > attr->ia_size) { 1160 if (ocfs2_should_order_data(inode)) { 1161 status = ocfs2_begin_ordered_truncate(inode, 1162 attr->ia_size); 1163 if (status) 1164 goto bail_unlock; 1165 } 1166 status = ocfs2_truncate_file(inode, bh, attr->ia_size); 1167 } else 1168 status = ocfs2_extend_file(inode, bh, attr->ia_size); 1169 if (status < 0) { 1170 if (status != -ENOSPC) 1171 mlog_errno(status); 1172 status = -ENOSPC; 1173 goto bail_unlock; 1174 } 1175 } 1176 1177 if ((attr->ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) || 1178 (attr->ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) { 1179 /* 1180 * Gather pointers to quota structures so that allocation / 1181 * freeing of quota structures happens here and not inside 1182 * dquot_transfer() where we have problems with lock ordering 1183 */ 1184 if (attr->ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid 1185 && OCFS2_HAS_RO_COMPAT_FEATURE(sb, 1186 OCFS2_FEATURE_RO_COMPAT_USRQUOTA)) { 1187 transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(attr->ia_uid)); 1188 if (!transfer_to[USRQUOTA]) { 1189 status = -ESRCH; 1190 goto bail_unlock; 1191 } 1192 } 1193 if (attr->ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid 1194 && OCFS2_HAS_RO_COMPAT_FEATURE(sb, 1195 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA)) { 1196 transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(attr->ia_gid)); 1197 if (!transfer_to[GRPQUOTA]) { 1198 status = -ESRCH; 1199 goto bail_unlock; 1200 } 1201 } 1202 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS + 1203 2 * ocfs2_quota_trans_credits(sb)); 1204 if (IS_ERR(handle)) { 1205 status = PTR_ERR(handle); 1206 mlog_errno(status); 1207 goto bail_unlock; 1208 } 1209 status = __dquot_transfer(inode, transfer_to); 1210 if (status < 0) 1211 goto bail_commit; 1212 } else { 1213 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 1214 if (IS_ERR(handle)) { 1215 status = PTR_ERR(handle); 1216 mlog_errno(status); 1217 goto bail_unlock; 1218 } 1219 } 1220 1221 setattr_copy(inode, attr); 1222 mark_inode_dirty(inode); 1223 1224 status = ocfs2_mark_inode_dirty(handle, inode, bh); 1225 if (status < 0) 1226 mlog_errno(status); 1227 1228 bail_commit: 1229 ocfs2_commit_trans(osb, handle); 1230 bail_unlock: 1231 ocfs2_inode_unlock(inode, 1); 1232 bail_unlock_rw: 1233 if (size_change) 1234 ocfs2_rw_unlock(inode, 1); 1235 bail: 1236 brelse(bh); 1237 1238 /* Release quota pointers in case we acquired them */ 1239 for (qtype = 0; qtype < MAXQUOTAS; qtype++) 1240 dqput(transfer_to[qtype]); 1241 1242 if (!status && attr->ia_valid & ATTR_MODE) { 1243 status = ocfs2_acl_chmod(inode); 1244 if (status < 0) 1245 mlog_errno(status); 1246 } 1247 1248 return status; 1249 } 1250 1251 int ocfs2_getattr(struct vfsmount *mnt, 1252 struct dentry *dentry, 1253 struct kstat *stat) 1254 { 1255 struct inode *inode = dentry->d_inode; 1256 struct super_block *sb = dentry->d_inode->i_sb; 1257 struct ocfs2_super *osb = sb->s_fs_info; 1258 int err; 1259 1260 err = ocfs2_inode_revalidate(dentry); 1261 if (err) { 1262 if (err != -ENOENT) 1263 mlog_errno(err); 1264 goto bail; 1265 } 1266 1267 generic_fillattr(inode, stat); 1268 1269 /* We set the blksize from the cluster size for performance */ 1270 stat->blksize = osb->s_clustersize; 1271 1272 bail: 1273 return err; 1274 } 1275 1276 int ocfs2_permission(struct inode *inode, int mask) 1277 { 1278 int ret; 1279 1280 if (mask & MAY_NOT_BLOCK) 1281 return -ECHILD; 1282 1283 ret = ocfs2_inode_lock(inode, NULL, 0); 1284 if (ret) { 1285 if (ret != -ENOENT) 1286 mlog_errno(ret); 1287 goto out; 1288 } 1289 1290 ret = generic_permission(inode, mask); 1291 1292 ocfs2_inode_unlock(inode, 0); 1293 out: 1294 return ret; 1295 } 1296 1297 static int __ocfs2_write_remove_suid(struct inode *inode, 1298 struct buffer_head *bh) 1299 { 1300 int ret; 1301 handle_t *handle; 1302 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1303 struct ocfs2_dinode *di; 1304 1305 trace_ocfs2_write_remove_suid( 1306 (unsigned long long)OCFS2_I(inode)->ip_blkno, 1307 inode->i_mode); 1308 1309 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 1310 if (IS_ERR(handle)) { 1311 ret = PTR_ERR(handle); 1312 mlog_errno(ret); 1313 goto out; 1314 } 1315 1316 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh, 1317 OCFS2_JOURNAL_ACCESS_WRITE); 1318 if (ret < 0) { 1319 mlog_errno(ret); 1320 goto out_trans; 1321 } 1322 1323 inode->i_mode &= ~S_ISUID; 1324 if ((inode->i_mode & S_ISGID) && (inode->i_mode & S_IXGRP)) 1325 inode->i_mode &= ~S_ISGID; 1326 1327 di = (struct ocfs2_dinode *) bh->b_data; 1328 di->i_mode = cpu_to_le16(inode->i_mode); 1329 1330 ocfs2_journal_dirty(handle, bh); 1331 1332 out_trans: 1333 ocfs2_commit_trans(osb, handle); 1334 out: 1335 return ret; 1336 } 1337 1338 /* 1339 * Will look for holes and unwritten extents in the range starting at 1340 * pos for count bytes (inclusive). 1341 */ 1342 static int ocfs2_check_range_for_holes(struct inode *inode, loff_t pos, 1343 size_t count) 1344 { 1345 int ret = 0; 1346 unsigned int extent_flags; 1347 u32 cpos, clusters, extent_len, phys_cpos; 1348 struct super_block *sb = inode->i_sb; 1349 1350 cpos = pos >> OCFS2_SB(sb)->s_clustersize_bits; 1351 clusters = ocfs2_clusters_for_bytes(sb, pos + count) - cpos; 1352 1353 while (clusters) { 1354 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len, 1355 &extent_flags); 1356 if (ret < 0) { 1357 mlog_errno(ret); 1358 goto out; 1359 } 1360 1361 if (phys_cpos == 0 || (extent_flags & OCFS2_EXT_UNWRITTEN)) { 1362 ret = 1; 1363 break; 1364 } 1365 1366 if (extent_len > clusters) 1367 extent_len = clusters; 1368 1369 clusters -= extent_len; 1370 cpos += extent_len; 1371 } 1372 out: 1373 return ret; 1374 } 1375 1376 static int ocfs2_write_remove_suid(struct inode *inode) 1377 { 1378 int ret; 1379 struct buffer_head *bh = NULL; 1380 1381 ret = ocfs2_read_inode_block(inode, &bh); 1382 if (ret < 0) { 1383 mlog_errno(ret); 1384 goto out; 1385 } 1386 1387 ret = __ocfs2_write_remove_suid(inode, bh); 1388 out: 1389 brelse(bh); 1390 return ret; 1391 } 1392 1393 /* 1394 * Allocate enough extents to cover the region starting at byte offset 1395 * start for len bytes. Existing extents are skipped, any extents 1396 * added are marked as "unwritten". 1397 */ 1398 static int ocfs2_allocate_unwritten_extents(struct inode *inode, 1399 u64 start, u64 len) 1400 { 1401 int ret; 1402 u32 cpos, phys_cpos, clusters, alloc_size; 1403 u64 end = start + len; 1404 struct buffer_head *di_bh = NULL; 1405 1406 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 1407 ret = ocfs2_read_inode_block(inode, &di_bh); 1408 if (ret) { 1409 mlog_errno(ret); 1410 goto out; 1411 } 1412 1413 /* 1414 * Nothing to do if the requested reservation range 1415 * fits within the inode. 1416 */ 1417 if (ocfs2_size_fits_inline_data(di_bh, end)) 1418 goto out; 1419 1420 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh); 1421 if (ret) { 1422 mlog_errno(ret); 1423 goto out; 1424 } 1425 } 1426 1427 /* 1428 * We consider both start and len to be inclusive. 1429 */ 1430 cpos = start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits; 1431 clusters = ocfs2_clusters_for_bytes(inode->i_sb, start + len); 1432 clusters -= cpos; 1433 1434 while (clusters) { 1435 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, 1436 &alloc_size, NULL); 1437 if (ret) { 1438 mlog_errno(ret); 1439 goto out; 1440 } 1441 1442 /* 1443 * Hole or existing extent len can be arbitrary, so 1444 * cap it to our own allocation request. 1445 */ 1446 if (alloc_size > clusters) 1447 alloc_size = clusters; 1448 1449 if (phys_cpos) { 1450 /* 1451 * We already have an allocation at this 1452 * region so we can safely skip it. 1453 */ 1454 goto next; 1455 } 1456 1457 ret = __ocfs2_extend_allocation(inode, cpos, alloc_size, 1); 1458 if (ret) { 1459 if (ret != -ENOSPC) 1460 mlog_errno(ret); 1461 goto out; 1462 } 1463 1464 next: 1465 cpos += alloc_size; 1466 clusters -= alloc_size; 1467 } 1468 1469 ret = 0; 1470 out: 1471 1472 brelse(di_bh); 1473 return ret; 1474 } 1475 1476 /* 1477 * Truncate a byte range, avoiding pages within partial clusters. This 1478 * preserves those pages for the zeroing code to write to. 1479 */ 1480 static void ocfs2_truncate_cluster_pages(struct inode *inode, u64 byte_start, 1481 u64 byte_len) 1482 { 1483 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1484 loff_t start, end; 1485 struct address_space *mapping = inode->i_mapping; 1486 1487 start = (loff_t)ocfs2_align_bytes_to_clusters(inode->i_sb, byte_start); 1488 end = byte_start + byte_len; 1489 end = end & ~(osb->s_clustersize - 1); 1490 1491 if (start < end) { 1492 unmap_mapping_range(mapping, start, end - start, 0); 1493 truncate_inode_pages_range(mapping, start, end - 1); 1494 } 1495 } 1496 1497 static int ocfs2_zero_partial_clusters(struct inode *inode, 1498 u64 start, u64 len) 1499 { 1500 int ret = 0; 1501 u64 tmpend, end = start + len; 1502 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1503 unsigned int csize = osb->s_clustersize; 1504 handle_t *handle; 1505 1506 /* 1507 * The "start" and "end" values are NOT necessarily part of 1508 * the range whose allocation is being deleted. Rather, this 1509 * is what the user passed in with the request. We must zero 1510 * partial clusters here. There's no need to worry about 1511 * physical allocation - the zeroing code knows to skip holes. 1512 */ 1513 trace_ocfs2_zero_partial_clusters( 1514 (unsigned long long)OCFS2_I(inode)->ip_blkno, 1515 (unsigned long long)start, (unsigned long long)end); 1516 1517 /* 1518 * If both edges are on a cluster boundary then there's no 1519 * zeroing required as the region is part of the allocation to 1520 * be truncated. 1521 */ 1522 if ((start & (csize - 1)) == 0 && (end & (csize - 1)) == 0) 1523 goto out; 1524 1525 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 1526 if (IS_ERR(handle)) { 1527 ret = PTR_ERR(handle); 1528 mlog_errno(ret); 1529 goto out; 1530 } 1531 1532 /* 1533 * We want to get the byte offset of the end of the 1st cluster. 1534 */ 1535 tmpend = (u64)osb->s_clustersize + (start & ~(osb->s_clustersize - 1)); 1536 if (tmpend > end) 1537 tmpend = end; 1538 1539 trace_ocfs2_zero_partial_clusters_range1((unsigned long long)start, 1540 (unsigned long long)tmpend); 1541 1542 ret = ocfs2_zero_range_for_truncate(inode, handle, start, tmpend); 1543 if (ret) 1544 mlog_errno(ret); 1545 1546 if (tmpend < end) { 1547 /* 1548 * This may make start and end equal, but the zeroing 1549 * code will skip any work in that case so there's no 1550 * need to catch it up here. 1551 */ 1552 start = end & ~(osb->s_clustersize - 1); 1553 1554 trace_ocfs2_zero_partial_clusters_range2( 1555 (unsigned long long)start, (unsigned long long)end); 1556 1557 ret = ocfs2_zero_range_for_truncate(inode, handle, start, end); 1558 if (ret) 1559 mlog_errno(ret); 1560 } 1561 1562 ocfs2_commit_trans(osb, handle); 1563 out: 1564 return ret; 1565 } 1566 1567 static int ocfs2_find_rec(struct ocfs2_extent_list *el, u32 pos) 1568 { 1569 int i; 1570 struct ocfs2_extent_rec *rec = NULL; 1571 1572 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) { 1573 1574 rec = &el->l_recs[i]; 1575 1576 if (le32_to_cpu(rec->e_cpos) < pos) 1577 break; 1578 } 1579 1580 return i; 1581 } 1582 1583 /* 1584 * Helper to calculate the punching pos and length in one run, we handle the 1585 * following three cases in order: 1586 * 1587 * - remove the entire record 1588 * - remove a partial record 1589 * - no record needs to be removed (hole-punching completed) 1590 */ 1591 static void ocfs2_calc_trunc_pos(struct inode *inode, 1592 struct ocfs2_extent_list *el, 1593 struct ocfs2_extent_rec *rec, 1594 u32 trunc_start, u32 *trunc_cpos, 1595 u32 *trunc_len, u32 *trunc_end, 1596 u64 *blkno, int *done) 1597 { 1598 int ret = 0; 1599 u32 coff, range; 1600 1601 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 1602 1603 if (le32_to_cpu(rec->e_cpos) >= trunc_start) { 1604 /* 1605 * remove an entire extent record. 1606 */ 1607 *trunc_cpos = le32_to_cpu(rec->e_cpos); 1608 /* 1609 * Skip holes if any. 1610 */ 1611 if (range < *trunc_end) 1612 *trunc_end = range; 1613 *trunc_len = *trunc_end - le32_to_cpu(rec->e_cpos); 1614 *blkno = le64_to_cpu(rec->e_blkno); 1615 *trunc_end = le32_to_cpu(rec->e_cpos); 1616 } else if (range > trunc_start) { 1617 /* 1618 * remove a partial extent record, which means we're 1619 * removing the last extent record. 1620 */ 1621 *trunc_cpos = trunc_start; 1622 /* 1623 * skip hole if any. 1624 */ 1625 if (range < *trunc_end) 1626 *trunc_end = range; 1627 *trunc_len = *trunc_end - trunc_start; 1628 coff = trunc_start - le32_to_cpu(rec->e_cpos); 1629 *blkno = le64_to_cpu(rec->e_blkno) + 1630 ocfs2_clusters_to_blocks(inode->i_sb, coff); 1631 *trunc_end = trunc_start; 1632 } else { 1633 /* 1634 * It may have two following possibilities: 1635 * 1636 * - last record has been removed 1637 * - trunc_start was within a hole 1638 * 1639 * both two cases mean the completion of hole punching. 1640 */ 1641 ret = 1; 1642 } 1643 1644 *done = ret; 1645 } 1646 1647 static int ocfs2_remove_inode_range(struct inode *inode, 1648 struct buffer_head *di_bh, u64 byte_start, 1649 u64 byte_len) 1650 { 1651 int ret = 0, flags = 0, done = 0, i; 1652 u32 trunc_start, trunc_len, trunc_end, trunc_cpos, phys_cpos; 1653 u32 cluster_in_el; 1654 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1655 struct ocfs2_cached_dealloc_ctxt dealloc; 1656 struct address_space *mapping = inode->i_mapping; 1657 struct ocfs2_extent_tree et; 1658 struct ocfs2_path *path = NULL; 1659 struct ocfs2_extent_list *el = NULL; 1660 struct ocfs2_extent_rec *rec = NULL; 1661 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 1662 u64 blkno, refcount_loc = le64_to_cpu(di->i_refcount_loc); 1663 1664 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh); 1665 ocfs2_init_dealloc_ctxt(&dealloc); 1666 1667 trace_ocfs2_remove_inode_range( 1668 (unsigned long long)OCFS2_I(inode)->ip_blkno, 1669 (unsigned long long)byte_start, 1670 (unsigned long long)byte_len); 1671 1672 if (byte_len == 0) 1673 return 0; 1674 1675 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 1676 ret = ocfs2_truncate_inline(inode, di_bh, byte_start, 1677 byte_start + byte_len, 0); 1678 if (ret) { 1679 mlog_errno(ret); 1680 goto out; 1681 } 1682 /* 1683 * There's no need to get fancy with the page cache 1684 * truncate of an inline-data inode. We're talking 1685 * about less than a page here, which will be cached 1686 * in the dinode buffer anyway. 1687 */ 1688 unmap_mapping_range(mapping, 0, 0, 0); 1689 truncate_inode_pages(mapping, 0); 1690 goto out; 1691 } 1692 1693 /* 1694 * For reflinks, we may need to CoW 2 clusters which might be 1695 * partially zero'd later, if hole's start and end offset were 1696 * within one cluster(means is not exactly aligned to clustersize). 1697 */ 1698 1699 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) { 1700 1701 ret = ocfs2_cow_file_pos(inode, di_bh, byte_start); 1702 if (ret) { 1703 mlog_errno(ret); 1704 goto out; 1705 } 1706 1707 ret = ocfs2_cow_file_pos(inode, di_bh, byte_start + byte_len); 1708 if (ret) { 1709 mlog_errno(ret); 1710 goto out; 1711 } 1712 } 1713 1714 trunc_start = ocfs2_clusters_for_bytes(osb->sb, byte_start); 1715 trunc_end = (byte_start + byte_len) >> osb->s_clustersize_bits; 1716 cluster_in_el = trunc_end; 1717 1718 ret = ocfs2_zero_partial_clusters(inode, byte_start, byte_len); 1719 if (ret) { 1720 mlog_errno(ret); 1721 goto out; 1722 } 1723 1724 path = ocfs2_new_path_from_et(&et); 1725 if (!path) { 1726 ret = -ENOMEM; 1727 mlog_errno(ret); 1728 goto out; 1729 } 1730 1731 while (trunc_end > trunc_start) { 1732 1733 ret = ocfs2_find_path(INODE_CACHE(inode), path, 1734 cluster_in_el); 1735 if (ret) { 1736 mlog_errno(ret); 1737 goto out; 1738 } 1739 1740 el = path_leaf_el(path); 1741 1742 i = ocfs2_find_rec(el, trunc_end); 1743 /* 1744 * Need to go to previous extent block. 1745 */ 1746 if (i < 0) { 1747 if (path->p_tree_depth == 0) 1748 break; 1749 1750 ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, 1751 path, 1752 &cluster_in_el); 1753 if (ret) { 1754 mlog_errno(ret); 1755 goto out; 1756 } 1757 1758 /* 1759 * We've reached the leftmost extent block, 1760 * it's safe to leave. 1761 */ 1762 if (cluster_in_el == 0) 1763 break; 1764 1765 /* 1766 * The 'pos' searched for previous extent block is 1767 * always one cluster less than actual trunc_end. 1768 */ 1769 trunc_end = cluster_in_el + 1; 1770 1771 ocfs2_reinit_path(path, 1); 1772 1773 continue; 1774 1775 } else 1776 rec = &el->l_recs[i]; 1777 1778 ocfs2_calc_trunc_pos(inode, el, rec, trunc_start, &trunc_cpos, 1779 &trunc_len, &trunc_end, &blkno, &done); 1780 if (done) 1781 break; 1782 1783 flags = rec->e_flags; 1784 phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, blkno); 1785 1786 ret = ocfs2_remove_btree_range(inode, &et, trunc_cpos, 1787 phys_cpos, trunc_len, flags, 1788 &dealloc, refcount_loc); 1789 if (ret < 0) { 1790 mlog_errno(ret); 1791 goto out; 1792 } 1793 1794 cluster_in_el = trunc_end; 1795 1796 ocfs2_reinit_path(path, 1); 1797 } 1798 1799 ocfs2_truncate_cluster_pages(inode, byte_start, byte_len); 1800 1801 out: 1802 ocfs2_schedule_truncate_log_flush(osb, 1); 1803 ocfs2_run_deallocs(osb, &dealloc); 1804 1805 return ret; 1806 } 1807 1808 /* 1809 * Parts of this function taken from xfs_change_file_space() 1810 */ 1811 static int __ocfs2_change_file_space(struct file *file, struct inode *inode, 1812 loff_t f_pos, unsigned int cmd, 1813 struct ocfs2_space_resv *sr, 1814 int change_size) 1815 { 1816 int ret; 1817 s64 llen; 1818 loff_t size; 1819 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1820 struct buffer_head *di_bh = NULL; 1821 handle_t *handle; 1822 unsigned long long max_off = inode->i_sb->s_maxbytes; 1823 1824 if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb)) 1825 return -EROFS; 1826 1827 mutex_lock(&inode->i_mutex); 1828 1829 /* 1830 * This prevents concurrent writes on other nodes 1831 */ 1832 ret = ocfs2_rw_lock(inode, 1); 1833 if (ret) { 1834 mlog_errno(ret); 1835 goto out; 1836 } 1837 1838 ret = ocfs2_inode_lock(inode, &di_bh, 1); 1839 if (ret) { 1840 mlog_errno(ret); 1841 goto out_rw_unlock; 1842 } 1843 1844 if (inode->i_flags & (S_IMMUTABLE|S_APPEND)) { 1845 ret = -EPERM; 1846 goto out_inode_unlock; 1847 } 1848 1849 switch (sr->l_whence) { 1850 case 0: /*SEEK_SET*/ 1851 break; 1852 case 1: /*SEEK_CUR*/ 1853 sr->l_start += f_pos; 1854 break; 1855 case 2: /*SEEK_END*/ 1856 sr->l_start += i_size_read(inode); 1857 break; 1858 default: 1859 ret = -EINVAL; 1860 goto out_inode_unlock; 1861 } 1862 sr->l_whence = 0; 1863 1864 llen = sr->l_len > 0 ? sr->l_len - 1 : sr->l_len; 1865 1866 if (sr->l_start < 0 1867 || sr->l_start > max_off 1868 || (sr->l_start + llen) < 0 1869 || (sr->l_start + llen) > max_off) { 1870 ret = -EINVAL; 1871 goto out_inode_unlock; 1872 } 1873 size = sr->l_start + sr->l_len; 1874 1875 if (cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) { 1876 if (sr->l_len <= 0) { 1877 ret = -EINVAL; 1878 goto out_inode_unlock; 1879 } 1880 } 1881 1882 if (file && should_remove_suid(file->f_path.dentry)) { 1883 ret = __ocfs2_write_remove_suid(inode, di_bh); 1884 if (ret) { 1885 mlog_errno(ret); 1886 goto out_inode_unlock; 1887 } 1888 } 1889 1890 down_write(&OCFS2_I(inode)->ip_alloc_sem); 1891 switch (cmd) { 1892 case OCFS2_IOC_RESVSP: 1893 case OCFS2_IOC_RESVSP64: 1894 /* 1895 * This takes unsigned offsets, but the signed ones we 1896 * pass have been checked against overflow above. 1897 */ 1898 ret = ocfs2_allocate_unwritten_extents(inode, sr->l_start, 1899 sr->l_len); 1900 break; 1901 case OCFS2_IOC_UNRESVSP: 1902 case OCFS2_IOC_UNRESVSP64: 1903 ret = ocfs2_remove_inode_range(inode, di_bh, sr->l_start, 1904 sr->l_len); 1905 break; 1906 default: 1907 ret = -EINVAL; 1908 } 1909 up_write(&OCFS2_I(inode)->ip_alloc_sem); 1910 if (ret) { 1911 mlog_errno(ret); 1912 goto out_inode_unlock; 1913 } 1914 1915 /* 1916 * We update c/mtime for these changes 1917 */ 1918 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 1919 if (IS_ERR(handle)) { 1920 ret = PTR_ERR(handle); 1921 mlog_errno(ret); 1922 goto out_inode_unlock; 1923 } 1924 1925 if (change_size && i_size_read(inode) < size) 1926 i_size_write(inode, size); 1927 1928 inode->i_ctime = inode->i_mtime = CURRENT_TIME; 1929 ret = ocfs2_mark_inode_dirty(handle, inode, di_bh); 1930 if (ret < 0) 1931 mlog_errno(ret); 1932 1933 if (file && (file->f_flags & O_SYNC)) 1934 handle->h_sync = 1; 1935 1936 ocfs2_commit_trans(osb, handle); 1937 1938 out_inode_unlock: 1939 brelse(di_bh); 1940 ocfs2_inode_unlock(inode, 1); 1941 out_rw_unlock: 1942 ocfs2_rw_unlock(inode, 1); 1943 1944 out: 1945 mutex_unlock(&inode->i_mutex); 1946 return ret; 1947 } 1948 1949 int ocfs2_change_file_space(struct file *file, unsigned int cmd, 1950 struct ocfs2_space_resv *sr) 1951 { 1952 struct inode *inode = file->f_path.dentry->d_inode; 1953 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1954 int ret; 1955 1956 if ((cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) && 1957 !ocfs2_writes_unwritten_extents(osb)) 1958 return -ENOTTY; 1959 else if ((cmd == OCFS2_IOC_UNRESVSP || cmd == OCFS2_IOC_UNRESVSP64) && 1960 !ocfs2_sparse_alloc(osb)) 1961 return -ENOTTY; 1962 1963 if (!S_ISREG(inode->i_mode)) 1964 return -EINVAL; 1965 1966 if (!(file->f_mode & FMODE_WRITE)) 1967 return -EBADF; 1968 1969 ret = mnt_want_write_file(file); 1970 if (ret) 1971 return ret; 1972 ret = __ocfs2_change_file_space(file, inode, file->f_pos, cmd, sr, 0); 1973 mnt_drop_write_file(file); 1974 return ret; 1975 } 1976 1977 static long ocfs2_fallocate(struct file *file, int mode, loff_t offset, 1978 loff_t len) 1979 { 1980 struct inode *inode = file->f_path.dentry->d_inode; 1981 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1982 struct ocfs2_space_resv sr; 1983 int change_size = 1; 1984 int cmd = OCFS2_IOC_RESVSP64; 1985 1986 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE)) 1987 return -EOPNOTSUPP; 1988 if (!ocfs2_writes_unwritten_extents(osb)) 1989 return -EOPNOTSUPP; 1990 1991 if (mode & FALLOC_FL_KEEP_SIZE) 1992 change_size = 0; 1993 1994 if (mode & FALLOC_FL_PUNCH_HOLE) 1995 cmd = OCFS2_IOC_UNRESVSP64; 1996 1997 sr.l_whence = 0; 1998 sr.l_start = (s64)offset; 1999 sr.l_len = (s64)len; 2000 2001 return __ocfs2_change_file_space(NULL, inode, offset, cmd, &sr, 2002 change_size); 2003 } 2004 2005 int ocfs2_check_range_for_refcount(struct inode *inode, loff_t pos, 2006 size_t count) 2007 { 2008 int ret = 0; 2009 unsigned int extent_flags; 2010 u32 cpos, clusters, extent_len, phys_cpos; 2011 struct super_block *sb = inode->i_sb; 2012 2013 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)) || 2014 !(OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) || 2015 OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) 2016 return 0; 2017 2018 cpos = pos >> OCFS2_SB(sb)->s_clustersize_bits; 2019 clusters = ocfs2_clusters_for_bytes(sb, pos + count) - cpos; 2020 2021 while (clusters) { 2022 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len, 2023 &extent_flags); 2024 if (ret < 0) { 2025 mlog_errno(ret); 2026 goto out; 2027 } 2028 2029 if (phys_cpos && (extent_flags & OCFS2_EXT_REFCOUNTED)) { 2030 ret = 1; 2031 break; 2032 } 2033 2034 if (extent_len > clusters) 2035 extent_len = clusters; 2036 2037 clusters -= extent_len; 2038 cpos += extent_len; 2039 } 2040 out: 2041 return ret; 2042 } 2043 2044 static void ocfs2_aiodio_wait(struct inode *inode) 2045 { 2046 wait_queue_head_t *wq = ocfs2_ioend_wq(inode); 2047 2048 wait_event(*wq, (atomic_read(&OCFS2_I(inode)->ip_unaligned_aio) == 0)); 2049 } 2050 2051 static int ocfs2_is_io_unaligned(struct inode *inode, size_t count, loff_t pos) 2052 { 2053 int blockmask = inode->i_sb->s_blocksize - 1; 2054 loff_t final_size = pos + count; 2055 2056 if ((pos & blockmask) || (final_size & blockmask)) 2057 return 1; 2058 return 0; 2059 } 2060 2061 static int ocfs2_prepare_inode_for_refcount(struct inode *inode, 2062 struct file *file, 2063 loff_t pos, size_t count, 2064 int *meta_level) 2065 { 2066 int ret; 2067 struct buffer_head *di_bh = NULL; 2068 u32 cpos = pos >> OCFS2_SB(inode->i_sb)->s_clustersize_bits; 2069 u32 clusters = 2070 ocfs2_clusters_for_bytes(inode->i_sb, pos + count) - cpos; 2071 2072 ret = ocfs2_inode_lock(inode, &di_bh, 1); 2073 if (ret) { 2074 mlog_errno(ret); 2075 goto out; 2076 } 2077 2078 *meta_level = 1; 2079 2080 ret = ocfs2_refcount_cow(inode, file, di_bh, cpos, clusters, UINT_MAX); 2081 if (ret) 2082 mlog_errno(ret); 2083 out: 2084 brelse(di_bh); 2085 return ret; 2086 } 2087 2088 static int ocfs2_prepare_inode_for_write(struct file *file, 2089 loff_t *ppos, 2090 size_t count, 2091 int appending, 2092 int *direct_io, 2093 int *has_refcount) 2094 { 2095 int ret = 0, meta_level = 0; 2096 struct dentry *dentry = file->f_path.dentry; 2097 struct inode *inode = dentry->d_inode; 2098 loff_t saved_pos = 0, end; 2099 2100 /* 2101 * We start with a read level meta lock and only jump to an ex 2102 * if we need to make modifications here. 2103 */ 2104 for(;;) { 2105 ret = ocfs2_inode_lock(inode, NULL, meta_level); 2106 if (ret < 0) { 2107 meta_level = -1; 2108 mlog_errno(ret); 2109 goto out; 2110 } 2111 2112 /* Clear suid / sgid if necessary. We do this here 2113 * instead of later in the write path because 2114 * remove_suid() calls ->setattr without any hint that 2115 * we may have already done our cluster locking. Since 2116 * ocfs2_setattr() *must* take cluster locks to 2117 * proceed, this will lead us to recursively lock the 2118 * inode. There's also the dinode i_size state which 2119 * can be lost via setattr during extending writes (we 2120 * set inode->i_size at the end of a write. */ 2121 if (should_remove_suid(dentry)) { 2122 if (meta_level == 0) { 2123 ocfs2_inode_unlock(inode, meta_level); 2124 meta_level = 1; 2125 continue; 2126 } 2127 2128 ret = ocfs2_write_remove_suid(inode); 2129 if (ret < 0) { 2130 mlog_errno(ret); 2131 goto out_unlock; 2132 } 2133 } 2134 2135 /* work on a copy of ppos until we're sure that we won't have 2136 * to recalculate it due to relocking. */ 2137 if (appending) 2138 saved_pos = i_size_read(inode); 2139 else 2140 saved_pos = *ppos; 2141 2142 end = saved_pos + count; 2143 2144 ret = ocfs2_check_range_for_refcount(inode, saved_pos, count); 2145 if (ret == 1) { 2146 ocfs2_inode_unlock(inode, meta_level); 2147 meta_level = -1; 2148 2149 ret = ocfs2_prepare_inode_for_refcount(inode, 2150 file, 2151 saved_pos, 2152 count, 2153 &meta_level); 2154 if (has_refcount) 2155 *has_refcount = 1; 2156 if (direct_io) 2157 *direct_io = 0; 2158 } 2159 2160 if (ret < 0) { 2161 mlog_errno(ret); 2162 goto out_unlock; 2163 } 2164 2165 /* 2166 * Skip the O_DIRECT checks if we don't need 2167 * them. 2168 */ 2169 if (!direct_io || !(*direct_io)) 2170 break; 2171 2172 /* 2173 * There's no sane way to do direct writes to an inode 2174 * with inline data. 2175 */ 2176 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) { 2177 *direct_io = 0; 2178 break; 2179 } 2180 2181 /* 2182 * Allowing concurrent direct writes means 2183 * i_size changes wouldn't be synchronized, so 2184 * one node could wind up truncating another 2185 * nodes writes. 2186 */ 2187 if (end > i_size_read(inode)) { 2188 *direct_io = 0; 2189 break; 2190 } 2191 2192 /* 2193 * We don't fill holes during direct io, so 2194 * check for them here. If any are found, the 2195 * caller will have to retake some cluster 2196 * locks and initiate the io as buffered. 2197 */ 2198 ret = ocfs2_check_range_for_holes(inode, saved_pos, count); 2199 if (ret == 1) { 2200 *direct_io = 0; 2201 ret = 0; 2202 } else if (ret < 0) 2203 mlog_errno(ret); 2204 break; 2205 } 2206 2207 if (appending) 2208 *ppos = saved_pos; 2209 2210 out_unlock: 2211 trace_ocfs2_prepare_inode_for_write(OCFS2_I(inode)->ip_blkno, 2212 saved_pos, appending, count, 2213 direct_io, has_refcount); 2214 2215 if (meta_level >= 0) 2216 ocfs2_inode_unlock(inode, meta_level); 2217 2218 out: 2219 return ret; 2220 } 2221 2222 static ssize_t ocfs2_file_aio_write(struct kiocb *iocb, 2223 const struct iovec *iov, 2224 unsigned long nr_segs, 2225 loff_t pos) 2226 { 2227 int ret, direct_io, appending, rw_level, have_alloc_sem = 0; 2228 int can_do_direct, has_refcount = 0; 2229 ssize_t written = 0; 2230 size_t ocount; /* original count */ 2231 size_t count; /* after file limit checks */ 2232 loff_t old_size, *ppos = &iocb->ki_pos; 2233 u32 old_clusters; 2234 struct file *file = iocb->ki_filp; 2235 struct inode *inode = file->f_path.dentry->d_inode; 2236 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2237 int full_coherency = !(osb->s_mount_opt & 2238 OCFS2_MOUNT_COHERENCY_BUFFERED); 2239 int unaligned_dio = 0; 2240 2241 trace_ocfs2_file_aio_write(inode, file, file->f_path.dentry, 2242 (unsigned long long)OCFS2_I(inode)->ip_blkno, 2243 file->f_path.dentry->d_name.len, 2244 file->f_path.dentry->d_name.name, 2245 (unsigned int)nr_segs); 2246 2247 if (iocb->ki_left == 0) 2248 return 0; 2249 2250 sb_start_write(inode->i_sb); 2251 2252 appending = file->f_flags & O_APPEND ? 1 : 0; 2253 direct_io = file->f_flags & O_DIRECT ? 1 : 0; 2254 2255 mutex_lock(&inode->i_mutex); 2256 2257 ocfs2_iocb_clear_sem_locked(iocb); 2258 2259 relock: 2260 /* to match setattr's i_mutex -> rw_lock ordering */ 2261 if (direct_io) { 2262 have_alloc_sem = 1; 2263 /* communicate with ocfs2_dio_end_io */ 2264 ocfs2_iocb_set_sem_locked(iocb); 2265 } 2266 2267 /* 2268 * Concurrent O_DIRECT writes are allowed with 2269 * mount_option "coherency=buffered". 2270 */ 2271 rw_level = (!direct_io || full_coherency); 2272 2273 ret = ocfs2_rw_lock(inode, rw_level); 2274 if (ret < 0) { 2275 mlog_errno(ret); 2276 goto out_sems; 2277 } 2278 2279 /* 2280 * O_DIRECT writes with "coherency=full" need to take EX cluster 2281 * inode_lock to guarantee coherency. 2282 */ 2283 if (direct_io && full_coherency) { 2284 /* 2285 * We need to take and drop the inode lock to force 2286 * other nodes to drop their caches. Buffered I/O 2287 * already does this in write_begin(). 2288 */ 2289 ret = ocfs2_inode_lock(inode, NULL, 1); 2290 if (ret < 0) { 2291 mlog_errno(ret); 2292 goto out_sems; 2293 } 2294 2295 ocfs2_inode_unlock(inode, 1); 2296 } 2297 2298 can_do_direct = direct_io; 2299 ret = ocfs2_prepare_inode_for_write(file, ppos, 2300 iocb->ki_left, appending, 2301 &can_do_direct, &has_refcount); 2302 if (ret < 0) { 2303 mlog_errno(ret); 2304 goto out; 2305 } 2306 2307 if (direct_io && !is_sync_kiocb(iocb)) 2308 unaligned_dio = ocfs2_is_io_unaligned(inode, iocb->ki_left, 2309 *ppos); 2310 2311 /* 2312 * We can't complete the direct I/O as requested, fall back to 2313 * buffered I/O. 2314 */ 2315 if (direct_io && !can_do_direct) { 2316 ocfs2_rw_unlock(inode, rw_level); 2317 2318 have_alloc_sem = 0; 2319 rw_level = -1; 2320 2321 direct_io = 0; 2322 goto relock; 2323 } 2324 2325 if (unaligned_dio) { 2326 /* 2327 * Wait on previous unaligned aio to complete before 2328 * proceeding. 2329 */ 2330 ocfs2_aiodio_wait(inode); 2331 2332 /* Mark the iocb as needing a decrement in ocfs2_dio_end_io */ 2333 atomic_inc(&OCFS2_I(inode)->ip_unaligned_aio); 2334 ocfs2_iocb_set_unaligned_aio(iocb); 2335 } 2336 2337 /* 2338 * To later detect whether a journal commit for sync writes is 2339 * necessary, we sample i_size, and cluster count here. 2340 */ 2341 old_size = i_size_read(inode); 2342 old_clusters = OCFS2_I(inode)->ip_clusters; 2343 2344 /* communicate with ocfs2_dio_end_io */ 2345 ocfs2_iocb_set_rw_locked(iocb, rw_level); 2346 2347 ret = generic_segment_checks(iov, &nr_segs, &ocount, 2348 VERIFY_READ); 2349 if (ret) 2350 goto out_dio; 2351 2352 count = ocount; 2353 ret = generic_write_checks(file, ppos, &count, 2354 S_ISBLK(inode->i_mode)); 2355 if (ret) 2356 goto out_dio; 2357 2358 if (direct_io) { 2359 written = generic_file_direct_write(iocb, iov, &nr_segs, *ppos, 2360 ppos, count, ocount); 2361 if (written < 0) { 2362 ret = written; 2363 goto out_dio; 2364 } 2365 } else { 2366 current->backing_dev_info = file->f_mapping->backing_dev_info; 2367 written = generic_file_buffered_write(iocb, iov, nr_segs, *ppos, 2368 ppos, count, 0); 2369 current->backing_dev_info = NULL; 2370 } 2371 2372 out_dio: 2373 /* buffered aio wouldn't have proper lock coverage today */ 2374 BUG_ON(ret == -EIOCBQUEUED && !(file->f_flags & O_DIRECT)); 2375 2376 if (((file->f_flags & O_DSYNC) && !direct_io) || IS_SYNC(inode) || 2377 ((file->f_flags & O_DIRECT) && !direct_io)) { 2378 ret = filemap_fdatawrite_range(file->f_mapping, pos, 2379 pos + count - 1); 2380 if (ret < 0) 2381 written = ret; 2382 2383 if (!ret && ((old_size != i_size_read(inode)) || 2384 (old_clusters != OCFS2_I(inode)->ip_clusters) || 2385 has_refcount)) { 2386 ret = jbd2_journal_force_commit(osb->journal->j_journal); 2387 if (ret < 0) 2388 written = ret; 2389 } 2390 2391 if (!ret) 2392 ret = filemap_fdatawait_range(file->f_mapping, pos, 2393 pos + count - 1); 2394 } 2395 2396 /* 2397 * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io 2398 * function pointer which is called when o_direct io completes so that 2399 * it can unlock our rw lock. 2400 * Unfortunately there are error cases which call end_io and others 2401 * that don't. so we don't have to unlock the rw_lock if either an 2402 * async dio is going to do it in the future or an end_io after an 2403 * error has already done it. 2404 */ 2405 if ((ret == -EIOCBQUEUED) || (!ocfs2_iocb_is_rw_locked(iocb))) { 2406 rw_level = -1; 2407 have_alloc_sem = 0; 2408 unaligned_dio = 0; 2409 } 2410 2411 if (unaligned_dio) { 2412 ocfs2_iocb_clear_unaligned_aio(iocb); 2413 atomic_dec(&OCFS2_I(inode)->ip_unaligned_aio); 2414 } 2415 2416 out: 2417 if (rw_level != -1) 2418 ocfs2_rw_unlock(inode, rw_level); 2419 2420 out_sems: 2421 if (have_alloc_sem) 2422 ocfs2_iocb_clear_sem_locked(iocb); 2423 2424 mutex_unlock(&inode->i_mutex); 2425 sb_end_write(inode->i_sb); 2426 2427 if (written) 2428 ret = written; 2429 return ret; 2430 } 2431 2432 static int ocfs2_splice_to_file(struct pipe_inode_info *pipe, 2433 struct file *out, 2434 struct splice_desc *sd) 2435 { 2436 int ret; 2437 2438 ret = ocfs2_prepare_inode_for_write(out, &sd->pos, 2439 sd->total_len, 0, NULL, NULL); 2440 if (ret < 0) { 2441 mlog_errno(ret); 2442 return ret; 2443 } 2444 2445 return splice_from_pipe_feed(pipe, sd, pipe_to_file); 2446 } 2447 2448 static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe, 2449 struct file *out, 2450 loff_t *ppos, 2451 size_t len, 2452 unsigned int flags) 2453 { 2454 int ret; 2455 struct address_space *mapping = out->f_mapping; 2456 struct inode *inode = mapping->host; 2457 struct splice_desc sd = { 2458 .total_len = len, 2459 .flags = flags, 2460 .pos = *ppos, 2461 .u.file = out, 2462 }; 2463 2464 2465 trace_ocfs2_file_splice_write(inode, out, out->f_path.dentry, 2466 (unsigned long long)OCFS2_I(inode)->ip_blkno, 2467 out->f_path.dentry->d_name.len, 2468 out->f_path.dentry->d_name.name, len); 2469 2470 if (pipe->inode) 2471 mutex_lock_nested(&pipe->inode->i_mutex, I_MUTEX_PARENT); 2472 2473 splice_from_pipe_begin(&sd); 2474 do { 2475 ret = splice_from_pipe_next(pipe, &sd); 2476 if (ret <= 0) 2477 break; 2478 2479 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD); 2480 ret = ocfs2_rw_lock(inode, 1); 2481 if (ret < 0) 2482 mlog_errno(ret); 2483 else { 2484 ret = ocfs2_splice_to_file(pipe, out, &sd); 2485 ocfs2_rw_unlock(inode, 1); 2486 } 2487 mutex_unlock(&inode->i_mutex); 2488 } while (ret > 0); 2489 splice_from_pipe_end(pipe, &sd); 2490 2491 if (pipe->inode) 2492 mutex_unlock(&pipe->inode->i_mutex); 2493 2494 if (sd.num_spliced) 2495 ret = sd.num_spliced; 2496 2497 if (ret > 0) { 2498 int err; 2499 2500 err = generic_write_sync(out, *ppos, ret); 2501 if (err) 2502 ret = err; 2503 else 2504 *ppos += ret; 2505 2506 balance_dirty_pages_ratelimited(mapping); 2507 } 2508 2509 return ret; 2510 } 2511 2512 static ssize_t ocfs2_file_splice_read(struct file *in, 2513 loff_t *ppos, 2514 struct pipe_inode_info *pipe, 2515 size_t len, 2516 unsigned int flags) 2517 { 2518 int ret = 0, lock_level = 0; 2519 struct inode *inode = in->f_path.dentry->d_inode; 2520 2521 trace_ocfs2_file_splice_read(inode, in, in->f_path.dentry, 2522 (unsigned long long)OCFS2_I(inode)->ip_blkno, 2523 in->f_path.dentry->d_name.len, 2524 in->f_path.dentry->d_name.name, len); 2525 2526 /* 2527 * See the comment in ocfs2_file_aio_read() 2528 */ 2529 ret = ocfs2_inode_lock_atime(inode, in->f_vfsmnt, &lock_level); 2530 if (ret < 0) { 2531 mlog_errno(ret); 2532 goto bail; 2533 } 2534 ocfs2_inode_unlock(inode, lock_level); 2535 2536 ret = generic_file_splice_read(in, ppos, pipe, len, flags); 2537 2538 bail: 2539 return ret; 2540 } 2541 2542 static ssize_t ocfs2_file_aio_read(struct kiocb *iocb, 2543 const struct iovec *iov, 2544 unsigned long nr_segs, 2545 loff_t pos) 2546 { 2547 int ret = 0, rw_level = -1, have_alloc_sem = 0, lock_level = 0; 2548 struct file *filp = iocb->ki_filp; 2549 struct inode *inode = filp->f_path.dentry->d_inode; 2550 2551 trace_ocfs2_file_aio_read(inode, filp, filp->f_path.dentry, 2552 (unsigned long long)OCFS2_I(inode)->ip_blkno, 2553 filp->f_path.dentry->d_name.len, 2554 filp->f_path.dentry->d_name.name, nr_segs); 2555 2556 2557 if (!inode) { 2558 ret = -EINVAL; 2559 mlog_errno(ret); 2560 goto bail; 2561 } 2562 2563 ocfs2_iocb_clear_sem_locked(iocb); 2564 2565 /* 2566 * buffered reads protect themselves in ->readpage(). O_DIRECT reads 2567 * need locks to protect pending reads from racing with truncate. 2568 */ 2569 if (filp->f_flags & O_DIRECT) { 2570 have_alloc_sem = 1; 2571 ocfs2_iocb_set_sem_locked(iocb); 2572 2573 ret = ocfs2_rw_lock(inode, 0); 2574 if (ret < 0) { 2575 mlog_errno(ret); 2576 goto bail; 2577 } 2578 rw_level = 0; 2579 /* communicate with ocfs2_dio_end_io */ 2580 ocfs2_iocb_set_rw_locked(iocb, rw_level); 2581 } 2582 2583 /* 2584 * We're fine letting folks race truncates and extending 2585 * writes with read across the cluster, just like they can 2586 * locally. Hence no rw_lock during read. 2587 * 2588 * Take and drop the meta data lock to update inode fields 2589 * like i_size. This allows the checks down below 2590 * generic_file_aio_read() a chance of actually working. 2591 */ 2592 ret = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level); 2593 if (ret < 0) { 2594 mlog_errno(ret); 2595 goto bail; 2596 } 2597 ocfs2_inode_unlock(inode, lock_level); 2598 2599 ret = generic_file_aio_read(iocb, iov, nr_segs, iocb->ki_pos); 2600 trace_generic_file_aio_read_ret(ret); 2601 2602 /* buffered aio wouldn't have proper lock coverage today */ 2603 BUG_ON(ret == -EIOCBQUEUED && !(filp->f_flags & O_DIRECT)); 2604 2605 /* see ocfs2_file_aio_write */ 2606 if (ret == -EIOCBQUEUED || !ocfs2_iocb_is_rw_locked(iocb)) { 2607 rw_level = -1; 2608 have_alloc_sem = 0; 2609 } 2610 2611 bail: 2612 if (have_alloc_sem) 2613 ocfs2_iocb_clear_sem_locked(iocb); 2614 2615 if (rw_level != -1) 2616 ocfs2_rw_unlock(inode, rw_level); 2617 2618 return ret; 2619 } 2620 2621 /* Refer generic_file_llseek_unlocked() */ 2622 static loff_t ocfs2_file_llseek(struct file *file, loff_t offset, int whence) 2623 { 2624 struct inode *inode = file->f_mapping->host; 2625 int ret = 0; 2626 2627 mutex_lock(&inode->i_mutex); 2628 2629 switch (whence) { 2630 case SEEK_SET: 2631 break; 2632 case SEEK_END: 2633 offset += inode->i_size; 2634 break; 2635 case SEEK_CUR: 2636 if (offset == 0) { 2637 offset = file->f_pos; 2638 goto out; 2639 } 2640 offset += file->f_pos; 2641 break; 2642 case SEEK_DATA: 2643 case SEEK_HOLE: 2644 ret = ocfs2_seek_data_hole_offset(file, &offset, whence); 2645 if (ret) 2646 goto out; 2647 break; 2648 default: 2649 ret = -EINVAL; 2650 goto out; 2651 } 2652 2653 if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET)) 2654 ret = -EINVAL; 2655 if (!ret && offset > inode->i_sb->s_maxbytes) 2656 ret = -EINVAL; 2657 if (ret) 2658 goto out; 2659 2660 if (offset != file->f_pos) { 2661 file->f_pos = offset; 2662 file->f_version = 0; 2663 } 2664 2665 out: 2666 mutex_unlock(&inode->i_mutex); 2667 if (ret) 2668 return ret; 2669 return offset; 2670 } 2671 2672 const struct inode_operations ocfs2_file_iops = { 2673 .setattr = ocfs2_setattr, 2674 .getattr = ocfs2_getattr, 2675 .permission = ocfs2_permission, 2676 .setxattr = generic_setxattr, 2677 .getxattr = generic_getxattr, 2678 .listxattr = ocfs2_listxattr, 2679 .removexattr = generic_removexattr, 2680 .fiemap = ocfs2_fiemap, 2681 .get_acl = ocfs2_iop_get_acl, 2682 }; 2683 2684 const struct inode_operations ocfs2_special_file_iops = { 2685 .setattr = ocfs2_setattr, 2686 .getattr = ocfs2_getattr, 2687 .permission = ocfs2_permission, 2688 .get_acl = ocfs2_iop_get_acl, 2689 }; 2690 2691 /* 2692 * Other than ->lock, keep ocfs2_fops and ocfs2_dops in sync with 2693 * ocfs2_fops_no_plocks and ocfs2_dops_no_plocks! 2694 */ 2695 const struct file_operations ocfs2_fops = { 2696 .llseek = ocfs2_file_llseek, 2697 .read = do_sync_read, 2698 .write = do_sync_write, 2699 .mmap = ocfs2_mmap, 2700 .fsync = ocfs2_sync_file, 2701 .release = ocfs2_file_release, 2702 .open = ocfs2_file_open, 2703 .aio_read = ocfs2_file_aio_read, 2704 .aio_write = ocfs2_file_aio_write, 2705 .unlocked_ioctl = ocfs2_ioctl, 2706 #ifdef CONFIG_COMPAT 2707 .compat_ioctl = ocfs2_compat_ioctl, 2708 #endif 2709 .lock = ocfs2_lock, 2710 .flock = ocfs2_flock, 2711 .splice_read = ocfs2_file_splice_read, 2712 .splice_write = ocfs2_file_splice_write, 2713 .fallocate = ocfs2_fallocate, 2714 }; 2715 2716 const struct file_operations ocfs2_dops = { 2717 .llseek = generic_file_llseek, 2718 .read = generic_read_dir, 2719 .readdir = ocfs2_readdir, 2720 .fsync = ocfs2_sync_file, 2721 .release = ocfs2_dir_release, 2722 .open = ocfs2_dir_open, 2723 .unlocked_ioctl = ocfs2_ioctl, 2724 #ifdef CONFIG_COMPAT 2725 .compat_ioctl = ocfs2_compat_ioctl, 2726 #endif 2727 .lock = ocfs2_lock, 2728 .flock = ocfs2_flock, 2729 }; 2730 2731 /* 2732 * POSIX-lockless variants of our file_operations. 2733 * 2734 * These will be used if the underlying cluster stack does not support 2735 * posix file locking, if the user passes the "localflocks" mount 2736 * option, or if we have a local-only fs. 2737 * 2738 * ocfs2_flock is in here because all stacks handle UNIX file locks, 2739 * so we still want it in the case of no stack support for 2740 * plocks. Internally, it will do the right thing when asked to ignore 2741 * the cluster. 2742 */ 2743 const struct file_operations ocfs2_fops_no_plocks = { 2744 .llseek = ocfs2_file_llseek, 2745 .read = do_sync_read, 2746 .write = do_sync_write, 2747 .mmap = ocfs2_mmap, 2748 .fsync = ocfs2_sync_file, 2749 .release = ocfs2_file_release, 2750 .open = ocfs2_file_open, 2751 .aio_read = ocfs2_file_aio_read, 2752 .aio_write = ocfs2_file_aio_write, 2753 .unlocked_ioctl = ocfs2_ioctl, 2754 #ifdef CONFIG_COMPAT 2755 .compat_ioctl = ocfs2_compat_ioctl, 2756 #endif 2757 .flock = ocfs2_flock, 2758 .splice_read = ocfs2_file_splice_read, 2759 .splice_write = ocfs2_file_splice_write, 2760 .fallocate = ocfs2_fallocate, 2761 }; 2762 2763 const struct file_operations ocfs2_dops_no_plocks = { 2764 .llseek = generic_file_llseek, 2765 .read = generic_read_dir, 2766 .readdir = ocfs2_readdir, 2767 .fsync = ocfs2_sync_file, 2768 .release = ocfs2_dir_release, 2769 .open = ocfs2_dir_open, 2770 .unlocked_ioctl = ocfs2_ioctl, 2771 #ifdef CONFIG_COMPAT 2772 .compat_ioctl = ocfs2_compat_ioctl, 2773 #endif 2774 .flock = ocfs2_flock, 2775 }; 2776