1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 4 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 5 */ 6 7 #include <linux/slab.h> 8 #include <linux/spinlock.h> 9 #include <linux/compat.h> 10 #include <linux/completion.h> 11 #include <linux/buffer_head.h> 12 #include <linux/pagemap.h> 13 #include <linux/uio.h> 14 #include <linux/blkdev.h> 15 #include <linux/mm.h> 16 #include <linux/mount.h> 17 #include <linux/fs.h> 18 #include <linux/gfs2_ondisk.h> 19 #include <linux/falloc.h> 20 #include <linux/swap.h> 21 #include <linux/crc32.h> 22 #include <linux/writeback.h> 23 #include <linux/uaccess.h> 24 #include <linux/dlm.h> 25 #include <linux/dlm_plock.h> 26 #include <linux/delay.h> 27 #include <linux/backing-dev.h> 28 #include <linux/fileattr.h> 29 30 #include "gfs2.h" 31 #include "incore.h" 32 #include "bmap.h" 33 #include "aops.h" 34 #include "dir.h" 35 #include "glock.h" 36 #include "glops.h" 37 #include "inode.h" 38 #include "log.h" 39 #include "meta_io.h" 40 #include "quota.h" 41 #include "rgrp.h" 42 #include "trans.h" 43 #include "util.h" 44 45 /** 46 * gfs2_llseek - seek to a location in a file 47 * @file: the file 48 * @offset: the offset 49 * @whence: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END) 50 * 51 * SEEK_END requires the glock for the file because it references the 52 * file's size. 53 * 54 * Returns: The new offset, or errno 55 */ 56 57 static loff_t gfs2_llseek(struct file *file, loff_t offset, int whence) 58 { 59 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host); 60 struct gfs2_holder i_gh; 61 loff_t error; 62 63 switch (whence) { 64 case SEEK_END: 65 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, 66 &i_gh); 67 if (!error) { 68 error = generic_file_llseek(file, offset, whence); 69 gfs2_glock_dq_uninit(&i_gh); 70 } 71 break; 72 73 case SEEK_DATA: 74 error = gfs2_seek_data(file, offset); 75 break; 76 77 case SEEK_HOLE: 78 error = gfs2_seek_hole(file, offset); 79 break; 80 81 case SEEK_CUR: 82 case SEEK_SET: 83 /* 84 * These don't reference inode->i_size and don't depend on the 85 * block mapping, so we don't need the glock. 86 */ 87 error = generic_file_llseek(file, offset, whence); 88 break; 89 default: 90 error = -EINVAL; 91 } 92 93 return error; 94 } 95 96 /** 97 * gfs2_readdir - Iterator for a directory 98 * @file: The directory to read from 99 * @ctx: What to feed directory entries to 100 * 101 * Returns: errno 102 */ 103 104 static int gfs2_readdir(struct file *file, struct dir_context *ctx) 105 { 106 struct inode *dir = file->f_mapping->host; 107 struct gfs2_inode *dip = GFS2_I(dir); 108 struct gfs2_holder d_gh; 109 int error; 110 111 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh); 112 if (error) 113 return error; 114 115 error = gfs2_dir_read(dir, ctx, &file->f_ra); 116 117 gfs2_glock_dq_uninit(&d_gh); 118 119 return error; 120 } 121 122 /* 123 * struct fsflag_gfs2flag 124 * 125 * The FS_JOURNAL_DATA_FL flag maps to GFS2_DIF_INHERIT_JDATA for directories, 126 * and to GFS2_DIF_JDATA for non-directories. 127 */ 128 static struct { 129 u32 fsflag; 130 u32 gfsflag; 131 } fsflag_gfs2flag[] = { 132 {FS_SYNC_FL, GFS2_DIF_SYNC}, 133 {FS_IMMUTABLE_FL, GFS2_DIF_IMMUTABLE}, 134 {FS_APPEND_FL, GFS2_DIF_APPENDONLY}, 135 {FS_NOATIME_FL, GFS2_DIF_NOATIME}, 136 {FS_INDEX_FL, GFS2_DIF_EXHASH}, 137 {FS_TOPDIR_FL, GFS2_DIF_TOPDIR}, 138 {FS_JOURNAL_DATA_FL, GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA}, 139 }; 140 141 static inline u32 gfs2_gfsflags_to_fsflags(struct inode *inode, u32 gfsflags) 142 { 143 int i; 144 u32 fsflags = 0; 145 146 if (S_ISDIR(inode->i_mode)) 147 gfsflags &= ~GFS2_DIF_JDATA; 148 else 149 gfsflags &= ~GFS2_DIF_INHERIT_JDATA; 150 151 for (i = 0; i < ARRAY_SIZE(fsflag_gfs2flag); i++) 152 if (gfsflags & fsflag_gfs2flag[i].gfsflag) 153 fsflags |= fsflag_gfs2flag[i].fsflag; 154 return fsflags; 155 } 156 157 int gfs2_fileattr_get(struct dentry *dentry, struct fileattr *fa) 158 { 159 struct inode *inode = d_inode(dentry); 160 struct gfs2_inode *ip = GFS2_I(inode); 161 struct gfs2_holder gh; 162 int error; 163 u32 fsflags; 164 165 if (d_is_special(dentry)) 166 return -ENOTTY; 167 168 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh); 169 error = gfs2_glock_nq(&gh); 170 if (error) 171 goto out_uninit; 172 173 fsflags = gfs2_gfsflags_to_fsflags(inode, ip->i_diskflags); 174 175 fileattr_fill_flags(fa, fsflags); 176 177 gfs2_glock_dq(&gh); 178 out_uninit: 179 gfs2_holder_uninit(&gh); 180 return error; 181 } 182 183 void gfs2_set_inode_flags(struct inode *inode) 184 { 185 struct gfs2_inode *ip = GFS2_I(inode); 186 unsigned int flags = inode->i_flags; 187 188 flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC); 189 if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode)) 190 flags |= S_NOSEC; 191 if (ip->i_diskflags & GFS2_DIF_IMMUTABLE) 192 flags |= S_IMMUTABLE; 193 if (ip->i_diskflags & GFS2_DIF_APPENDONLY) 194 flags |= S_APPEND; 195 if (ip->i_diskflags & GFS2_DIF_NOATIME) 196 flags |= S_NOATIME; 197 if (ip->i_diskflags & GFS2_DIF_SYNC) 198 flags |= S_SYNC; 199 inode->i_flags = flags; 200 } 201 202 /* Flags that can be set by user space */ 203 #define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA| \ 204 GFS2_DIF_IMMUTABLE| \ 205 GFS2_DIF_APPENDONLY| \ 206 GFS2_DIF_NOATIME| \ 207 GFS2_DIF_SYNC| \ 208 GFS2_DIF_TOPDIR| \ 209 GFS2_DIF_INHERIT_JDATA) 210 211 /** 212 * do_gfs2_set_flags - set flags on an inode 213 * @inode: The inode 214 * @reqflags: The flags to set 215 * @mask: Indicates which flags are valid 216 * @fsflags: The FS_* inode flags passed in 217 * 218 */ 219 static int do_gfs2_set_flags(struct inode *inode, u32 reqflags, u32 mask, 220 const u32 fsflags) 221 { 222 struct gfs2_inode *ip = GFS2_I(inode); 223 struct gfs2_sbd *sdp = GFS2_SB(inode); 224 struct buffer_head *bh; 225 struct gfs2_holder gh; 226 int error; 227 u32 new_flags, flags; 228 229 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 230 if (error) 231 return error; 232 233 error = 0; 234 flags = ip->i_diskflags; 235 new_flags = (flags & ~mask) | (reqflags & mask); 236 if ((new_flags ^ flags) == 0) 237 goto out; 238 239 error = -EPERM; 240 if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE)) 241 goto out; 242 if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY)) 243 goto out; 244 if (!IS_IMMUTABLE(inode)) { 245 error = gfs2_permission(&init_user_ns, inode, MAY_WRITE); 246 if (error) 247 goto out; 248 } 249 if ((flags ^ new_flags) & GFS2_DIF_JDATA) { 250 if (new_flags & GFS2_DIF_JDATA) 251 gfs2_log_flush(sdp, ip->i_gl, 252 GFS2_LOG_HEAD_FLUSH_NORMAL | 253 GFS2_LFC_SET_FLAGS); 254 error = filemap_fdatawrite(inode->i_mapping); 255 if (error) 256 goto out; 257 error = filemap_fdatawait(inode->i_mapping); 258 if (error) 259 goto out; 260 if (new_flags & GFS2_DIF_JDATA) 261 gfs2_ordered_del_inode(ip); 262 } 263 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 264 if (error) 265 goto out; 266 error = gfs2_meta_inode_buffer(ip, &bh); 267 if (error) 268 goto out_trans_end; 269 inode->i_ctime = current_time(inode); 270 gfs2_trans_add_meta(ip->i_gl, bh); 271 ip->i_diskflags = new_flags; 272 gfs2_dinode_out(ip, bh->b_data); 273 brelse(bh); 274 gfs2_set_inode_flags(inode); 275 gfs2_set_aops(inode); 276 out_trans_end: 277 gfs2_trans_end(sdp); 278 out: 279 gfs2_glock_dq_uninit(&gh); 280 return error; 281 } 282 283 int gfs2_fileattr_set(struct user_namespace *mnt_userns, 284 struct dentry *dentry, struct fileattr *fa) 285 { 286 struct inode *inode = d_inode(dentry); 287 u32 fsflags = fa->flags, gfsflags = 0; 288 u32 mask; 289 int i; 290 291 if (d_is_special(dentry)) 292 return -ENOTTY; 293 294 if (fileattr_has_fsx(fa)) 295 return -EOPNOTSUPP; 296 297 for (i = 0; i < ARRAY_SIZE(fsflag_gfs2flag); i++) { 298 if (fsflags & fsflag_gfs2flag[i].fsflag) { 299 fsflags &= ~fsflag_gfs2flag[i].fsflag; 300 gfsflags |= fsflag_gfs2flag[i].gfsflag; 301 } 302 } 303 if (fsflags || gfsflags & ~GFS2_FLAGS_USER_SET) 304 return -EINVAL; 305 306 mask = GFS2_FLAGS_USER_SET; 307 if (S_ISDIR(inode->i_mode)) { 308 mask &= ~GFS2_DIF_JDATA; 309 } else { 310 /* The GFS2_DIF_TOPDIR flag is only valid for directories. */ 311 if (gfsflags & GFS2_DIF_TOPDIR) 312 return -EINVAL; 313 mask &= ~(GFS2_DIF_TOPDIR | GFS2_DIF_INHERIT_JDATA); 314 } 315 316 return do_gfs2_set_flags(inode, gfsflags, mask, fsflags); 317 } 318 319 static int gfs2_getlabel(struct file *filp, char __user *label) 320 { 321 struct inode *inode = file_inode(filp); 322 struct gfs2_sbd *sdp = GFS2_SB(inode); 323 324 if (copy_to_user(label, sdp->sd_sb.sb_locktable, GFS2_LOCKNAME_LEN)) 325 return -EFAULT; 326 327 return 0; 328 } 329 330 static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 331 { 332 switch(cmd) { 333 case FITRIM: 334 return gfs2_fitrim(filp, (void __user *)arg); 335 case FS_IOC_GETFSLABEL: 336 return gfs2_getlabel(filp, (char __user *)arg); 337 } 338 339 return -ENOTTY; 340 } 341 342 #ifdef CONFIG_COMPAT 343 static long gfs2_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 344 { 345 switch(cmd) { 346 /* Keep this list in sync with gfs2_ioctl */ 347 case FITRIM: 348 case FS_IOC_GETFSLABEL: 349 break; 350 default: 351 return -ENOIOCTLCMD; 352 } 353 354 return gfs2_ioctl(filp, cmd, (unsigned long)compat_ptr(arg)); 355 } 356 #else 357 #define gfs2_compat_ioctl NULL 358 #endif 359 360 /** 361 * gfs2_size_hint - Give a hint to the size of a write request 362 * @filep: The struct file 363 * @offset: The file offset of the write 364 * @size: The length of the write 365 * 366 * When we are about to do a write, this function records the total 367 * write size in order to provide a suitable hint to the lower layers 368 * about how many blocks will be required. 369 * 370 */ 371 372 static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size) 373 { 374 struct inode *inode = file_inode(filep); 375 struct gfs2_sbd *sdp = GFS2_SB(inode); 376 struct gfs2_inode *ip = GFS2_I(inode); 377 size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift; 378 int hint = min_t(size_t, INT_MAX, blks); 379 380 if (hint > atomic_read(&ip->i_sizehint)) 381 atomic_set(&ip->i_sizehint, hint); 382 } 383 384 /** 385 * gfs2_allocate_page_backing - Allocate blocks for a write fault 386 * @page: The (locked) page to allocate backing for 387 * @length: Size of the allocation 388 * 389 * We try to allocate all the blocks required for the page in one go. This 390 * might fail for various reasons, so we keep trying until all the blocks to 391 * back this page are allocated. If some of the blocks are already allocated, 392 * that is ok too. 393 */ 394 static int gfs2_allocate_page_backing(struct page *page, unsigned int length) 395 { 396 u64 pos = page_offset(page); 397 398 do { 399 struct iomap iomap = { }; 400 401 if (gfs2_iomap_alloc(page->mapping->host, pos, length, &iomap)) 402 return -EIO; 403 404 if (length < iomap.length) 405 iomap.length = length; 406 length -= iomap.length; 407 pos += iomap.length; 408 } while (length > 0); 409 410 return 0; 411 } 412 413 /** 414 * gfs2_page_mkwrite - Make a shared, mmap()ed, page writable 415 * @vmf: The virtual memory fault containing the page to become writable 416 * 417 * When the page becomes writable, we need to ensure that we have 418 * blocks allocated on disk to back that page. 419 */ 420 421 static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 422 { 423 struct page *page = vmf->page; 424 struct inode *inode = file_inode(vmf->vma->vm_file); 425 struct gfs2_inode *ip = GFS2_I(inode); 426 struct gfs2_sbd *sdp = GFS2_SB(inode); 427 struct gfs2_alloc_parms ap = { .aflags = 0, }; 428 u64 offset = page_offset(page); 429 unsigned int data_blocks, ind_blocks, rblocks; 430 vm_fault_t ret = VM_FAULT_LOCKED; 431 struct gfs2_holder gh; 432 unsigned int length; 433 loff_t size; 434 int err; 435 436 sb_start_pagefault(inode->i_sb); 437 438 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 439 err = gfs2_glock_nq(&gh); 440 if (err) { 441 ret = block_page_mkwrite_return(err); 442 goto out_uninit; 443 } 444 445 /* Check page index against inode size */ 446 size = i_size_read(inode); 447 if (offset >= size) { 448 ret = VM_FAULT_SIGBUS; 449 goto out_unlock; 450 } 451 452 /* Update file times before taking page lock */ 453 file_update_time(vmf->vma->vm_file); 454 455 /* page is wholly or partially inside EOF */ 456 if (size - offset < PAGE_SIZE) 457 length = size - offset; 458 else 459 length = PAGE_SIZE; 460 461 gfs2_size_hint(vmf->vma->vm_file, offset, length); 462 463 set_bit(GLF_DIRTY, &ip->i_gl->gl_flags); 464 set_bit(GIF_SW_PAGED, &ip->i_flags); 465 466 /* 467 * iomap_writepage / iomap_writepages currently don't support inline 468 * files, so always unstuff here. 469 */ 470 471 if (!gfs2_is_stuffed(ip) && 472 !gfs2_write_alloc_required(ip, offset, length)) { 473 lock_page(page); 474 if (!PageUptodate(page) || page->mapping != inode->i_mapping) { 475 ret = VM_FAULT_NOPAGE; 476 unlock_page(page); 477 } 478 goto out_unlock; 479 } 480 481 err = gfs2_rindex_update(sdp); 482 if (err) { 483 ret = block_page_mkwrite_return(err); 484 goto out_unlock; 485 } 486 487 gfs2_write_calc_reserv(ip, length, &data_blocks, &ind_blocks); 488 ap.target = data_blocks + ind_blocks; 489 err = gfs2_quota_lock_check(ip, &ap); 490 if (err) { 491 ret = block_page_mkwrite_return(err); 492 goto out_unlock; 493 } 494 err = gfs2_inplace_reserve(ip, &ap); 495 if (err) { 496 ret = block_page_mkwrite_return(err); 497 goto out_quota_unlock; 498 } 499 500 rblocks = RES_DINODE + ind_blocks; 501 if (gfs2_is_jdata(ip)) 502 rblocks += data_blocks ? data_blocks : 1; 503 if (ind_blocks || data_blocks) { 504 rblocks += RES_STATFS + RES_QUOTA; 505 rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks); 506 } 507 err = gfs2_trans_begin(sdp, rblocks, 0); 508 if (err) { 509 ret = block_page_mkwrite_return(err); 510 goto out_trans_fail; 511 } 512 513 /* Unstuff, if required, and allocate backing blocks for page */ 514 if (gfs2_is_stuffed(ip)) { 515 err = gfs2_unstuff_dinode(ip); 516 if (err) { 517 ret = block_page_mkwrite_return(err); 518 goto out_trans_end; 519 } 520 } 521 522 lock_page(page); 523 /* If truncated, we must retry the operation, we may have raced 524 * with the glock demotion code. 525 */ 526 if (!PageUptodate(page) || page->mapping != inode->i_mapping) { 527 ret = VM_FAULT_NOPAGE; 528 goto out_page_locked; 529 } 530 531 err = gfs2_allocate_page_backing(page, length); 532 if (err) 533 ret = block_page_mkwrite_return(err); 534 535 out_page_locked: 536 if (ret != VM_FAULT_LOCKED) 537 unlock_page(page); 538 out_trans_end: 539 gfs2_trans_end(sdp); 540 out_trans_fail: 541 gfs2_inplace_release(ip); 542 out_quota_unlock: 543 gfs2_quota_unlock(ip); 544 out_unlock: 545 gfs2_glock_dq(&gh); 546 out_uninit: 547 gfs2_holder_uninit(&gh); 548 if (ret == VM_FAULT_LOCKED) { 549 set_page_dirty(page); 550 wait_for_stable_page(page); 551 } 552 sb_end_pagefault(inode->i_sb); 553 return ret; 554 } 555 556 static vm_fault_t gfs2_fault(struct vm_fault *vmf) 557 { 558 struct inode *inode = file_inode(vmf->vma->vm_file); 559 struct gfs2_inode *ip = GFS2_I(inode); 560 struct gfs2_holder gh; 561 vm_fault_t ret; 562 int err; 563 564 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh); 565 err = gfs2_glock_nq(&gh); 566 if (err) { 567 ret = block_page_mkwrite_return(err); 568 goto out_uninit; 569 } 570 ret = filemap_fault(vmf); 571 gfs2_glock_dq(&gh); 572 out_uninit: 573 gfs2_holder_uninit(&gh); 574 return ret; 575 } 576 577 static const struct vm_operations_struct gfs2_vm_ops = { 578 .fault = gfs2_fault, 579 .map_pages = filemap_map_pages, 580 .page_mkwrite = gfs2_page_mkwrite, 581 }; 582 583 /** 584 * gfs2_mmap 585 * @file: The file to map 586 * @vma: The VMA which described the mapping 587 * 588 * There is no need to get a lock here unless we should be updating 589 * atime. We ignore any locking errors since the only consequence is 590 * a missed atime update (which will just be deferred until later). 591 * 592 * Returns: 0 593 */ 594 595 static int gfs2_mmap(struct file *file, struct vm_area_struct *vma) 596 { 597 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host); 598 599 if (!(file->f_flags & O_NOATIME) && 600 !IS_NOATIME(&ip->i_inode)) { 601 struct gfs2_holder i_gh; 602 int error; 603 604 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, 605 &i_gh); 606 if (error) 607 return error; 608 /* grab lock to update inode */ 609 gfs2_glock_dq_uninit(&i_gh); 610 file_accessed(file); 611 } 612 vma->vm_ops = &gfs2_vm_ops; 613 614 return 0; 615 } 616 617 /** 618 * gfs2_open_common - This is common to open and atomic_open 619 * @inode: The inode being opened 620 * @file: The file being opened 621 * 622 * This maybe called under a glock or not depending upon how it has 623 * been called. We must always be called under a glock for regular 624 * files, however. For other file types, it does not matter whether 625 * we hold the glock or not. 626 * 627 * Returns: Error code or 0 for success 628 */ 629 630 int gfs2_open_common(struct inode *inode, struct file *file) 631 { 632 struct gfs2_file *fp; 633 int ret; 634 635 if (S_ISREG(inode->i_mode)) { 636 ret = generic_file_open(inode, file); 637 if (ret) 638 return ret; 639 } 640 641 fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS); 642 if (!fp) 643 return -ENOMEM; 644 645 mutex_init(&fp->f_fl_mutex); 646 647 gfs2_assert_warn(GFS2_SB(inode), !file->private_data); 648 file->private_data = fp; 649 if (file->f_mode & FMODE_WRITE) { 650 ret = gfs2_qa_get(GFS2_I(inode)); 651 if (ret) 652 goto fail; 653 } 654 return 0; 655 656 fail: 657 kfree(file->private_data); 658 file->private_data = NULL; 659 return ret; 660 } 661 662 /** 663 * gfs2_open - open a file 664 * @inode: the inode to open 665 * @file: the struct file for this opening 666 * 667 * After atomic_open, this function is only used for opening files 668 * which are already cached. We must still get the glock for regular 669 * files to ensure that we have the file size uptodate for the large 670 * file check which is in the common code. That is only an issue for 671 * regular files though. 672 * 673 * Returns: errno 674 */ 675 676 static int gfs2_open(struct inode *inode, struct file *file) 677 { 678 struct gfs2_inode *ip = GFS2_I(inode); 679 struct gfs2_holder i_gh; 680 int error; 681 bool need_unlock = false; 682 683 if (S_ISREG(ip->i_inode.i_mode)) { 684 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, 685 &i_gh); 686 if (error) 687 return error; 688 need_unlock = true; 689 } 690 691 error = gfs2_open_common(inode, file); 692 693 if (need_unlock) 694 gfs2_glock_dq_uninit(&i_gh); 695 696 return error; 697 } 698 699 /** 700 * gfs2_release - called to close a struct file 701 * @inode: the inode the struct file belongs to 702 * @file: the struct file being closed 703 * 704 * Returns: errno 705 */ 706 707 static int gfs2_release(struct inode *inode, struct file *file) 708 { 709 struct gfs2_inode *ip = GFS2_I(inode); 710 711 kfree(file->private_data); 712 file->private_data = NULL; 713 714 if (gfs2_rs_active(&ip->i_res)) 715 gfs2_rs_delete(ip, &inode->i_writecount); 716 if (file->f_mode & FMODE_WRITE) 717 gfs2_qa_put(ip); 718 return 0; 719 } 720 721 /** 722 * gfs2_fsync - sync the dirty data for a file (across the cluster) 723 * @file: the file that points to the dentry 724 * @start: the start position in the file to sync 725 * @end: the end position in the file to sync 726 * @datasync: set if we can ignore timestamp changes 727 * 728 * We split the data flushing here so that we don't wait for the data 729 * until after we've also sent the metadata to disk. Note that for 730 * data=ordered, we will write & wait for the data at the log flush 731 * stage anyway, so this is unlikely to make much of a difference 732 * except in the data=writeback case. 733 * 734 * If the fdatawrite fails due to any reason except -EIO, we will 735 * continue the remainder of the fsync, although we'll still report 736 * the error at the end. This is to match filemap_write_and_wait_range() 737 * behaviour. 738 * 739 * Returns: errno 740 */ 741 742 static int gfs2_fsync(struct file *file, loff_t start, loff_t end, 743 int datasync) 744 { 745 struct address_space *mapping = file->f_mapping; 746 struct inode *inode = mapping->host; 747 int sync_state = inode->i_state & I_DIRTY; 748 struct gfs2_inode *ip = GFS2_I(inode); 749 int ret = 0, ret1 = 0; 750 751 if (mapping->nrpages) { 752 ret1 = filemap_fdatawrite_range(mapping, start, end); 753 if (ret1 == -EIO) 754 return ret1; 755 } 756 757 if (!gfs2_is_jdata(ip)) 758 sync_state &= ~I_DIRTY_PAGES; 759 if (datasync) 760 sync_state &= ~I_DIRTY_SYNC; 761 762 if (sync_state) { 763 ret = sync_inode_metadata(inode, 1); 764 if (ret) 765 return ret; 766 if (gfs2_is_jdata(ip)) 767 ret = file_write_and_wait(file); 768 if (ret) 769 return ret; 770 gfs2_ail_flush(ip->i_gl, 1); 771 } 772 773 if (mapping->nrpages) 774 ret = file_fdatawait_range(file, start, end); 775 776 return ret ? ret : ret1; 777 } 778 779 static ssize_t gfs2_file_direct_read(struct kiocb *iocb, struct iov_iter *to, 780 struct gfs2_holder *gh) 781 { 782 struct file *file = iocb->ki_filp; 783 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host); 784 size_t count = iov_iter_count(to); 785 ssize_t ret; 786 787 if (!count) 788 return 0; /* skip atime */ 789 790 gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh); 791 ret = gfs2_glock_nq(gh); 792 if (ret) 793 goto out_uninit; 794 795 ret = iomap_dio_rw(iocb, to, &gfs2_iomap_ops, NULL, 0); 796 gfs2_glock_dq(gh); 797 out_uninit: 798 gfs2_holder_uninit(gh); 799 return ret; 800 } 801 802 static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from, 803 struct gfs2_holder *gh) 804 { 805 struct file *file = iocb->ki_filp; 806 struct inode *inode = file->f_mapping->host; 807 struct gfs2_inode *ip = GFS2_I(inode); 808 size_t len = iov_iter_count(from); 809 loff_t offset = iocb->ki_pos; 810 ssize_t ret; 811 812 /* 813 * Deferred lock, even if its a write, since we do no allocation on 814 * this path. All we need to change is the atime, and this lock mode 815 * ensures that other nodes have flushed their buffered read caches 816 * (i.e. their page cache entries for this inode). We do not, 817 * unfortunately, have the option of only flushing a range like the 818 * VFS does. 819 */ 820 gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, gh); 821 ret = gfs2_glock_nq(gh); 822 if (ret) 823 goto out_uninit; 824 825 /* Silently fall back to buffered I/O when writing beyond EOF */ 826 if (offset + len > i_size_read(&ip->i_inode)) 827 goto out; 828 829 ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL, 0); 830 if (ret == -ENOTBLK) 831 ret = 0; 832 out: 833 gfs2_glock_dq(gh); 834 out_uninit: 835 gfs2_holder_uninit(gh); 836 return ret; 837 } 838 839 static ssize_t gfs2_file_read_iter(struct kiocb *iocb, struct iov_iter *to) 840 { 841 struct gfs2_inode *ip; 842 struct gfs2_holder gh; 843 size_t written = 0; 844 ssize_t ret; 845 846 if (iocb->ki_flags & IOCB_DIRECT) { 847 ret = gfs2_file_direct_read(iocb, to, &gh); 848 if (likely(ret != -ENOTBLK)) 849 return ret; 850 iocb->ki_flags &= ~IOCB_DIRECT; 851 } 852 iocb->ki_flags |= IOCB_NOIO; 853 ret = generic_file_read_iter(iocb, to); 854 iocb->ki_flags &= ~IOCB_NOIO; 855 if (ret >= 0) { 856 if (!iov_iter_count(to)) 857 return ret; 858 written = ret; 859 } else { 860 if (ret != -EAGAIN) 861 return ret; 862 if (iocb->ki_flags & IOCB_NOWAIT) 863 return ret; 864 } 865 ip = GFS2_I(iocb->ki_filp->f_mapping->host); 866 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh); 867 ret = gfs2_glock_nq(&gh); 868 if (ret) 869 goto out_uninit; 870 ret = generic_file_read_iter(iocb, to); 871 if (ret > 0) 872 written += ret; 873 gfs2_glock_dq(&gh); 874 out_uninit: 875 gfs2_holder_uninit(&gh); 876 return written ? written : ret; 877 } 878 879 /** 880 * gfs2_file_write_iter - Perform a write to a file 881 * @iocb: The io context 882 * @from: The data to write 883 * 884 * We have to do a lock/unlock here to refresh the inode size for 885 * O_APPEND writes, otherwise we can land up writing at the wrong 886 * offset. There is still a race, but provided the app is using its 887 * own file locking, this will make O_APPEND work as expected. 888 * 889 */ 890 891 static ssize_t gfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 892 { 893 struct file *file = iocb->ki_filp; 894 struct inode *inode = file_inode(file); 895 struct gfs2_inode *ip = GFS2_I(inode); 896 struct gfs2_holder gh; 897 ssize_t ret; 898 899 gfs2_size_hint(file, iocb->ki_pos, iov_iter_count(from)); 900 901 if (iocb->ki_flags & IOCB_APPEND) { 902 ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh); 903 if (ret) 904 return ret; 905 gfs2_glock_dq_uninit(&gh); 906 } 907 908 inode_lock(inode); 909 ret = generic_write_checks(iocb, from); 910 if (ret <= 0) 911 goto out_unlock; 912 913 ret = file_remove_privs(file); 914 if (ret) 915 goto out_unlock; 916 917 ret = file_update_time(file); 918 if (ret) 919 goto out_unlock; 920 921 if (iocb->ki_flags & IOCB_DIRECT) { 922 struct address_space *mapping = file->f_mapping; 923 ssize_t buffered, ret2; 924 925 ret = gfs2_file_direct_write(iocb, from, &gh); 926 if (ret < 0 || !iov_iter_count(from)) 927 goto out_unlock; 928 929 iocb->ki_flags |= IOCB_DSYNC; 930 current->backing_dev_info = inode_to_bdi(inode); 931 buffered = iomap_file_buffered_write(iocb, from, &gfs2_iomap_ops); 932 current->backing_dev_info = NULL; 933 if (unlikely(buffered <= 0)) { 934 if (!ret) 935 ret = buffered; 936 goto out_unlock; 937 } 938 939 /* 940 * We need to ensure that the page cache pages are written to 941 * disk and invalidated to preserve the expected O_DIRECT 942 * semantics. If the writeback or invalidate fails, only report 943 * the direct I/O range as we don't know if the buffered pages 944 * made it to disk. 945 */ 946 iocb->ki_pos += buffered; 947 ret2 = generic_write_sync(iocb, buffered); 948 invalidate_mapping_pages(mapping, 949 (iocb->ki_pos - buffered) >> PAGE_SHIFT, 950 (iocb->ki_pos - 1) >> PAGE_SHIFT); 951 if (!ret || ret2 > 0) 952 ret += ret2; 953 } else { 954 current->backing_dev_info = inode_to_bdi(inode); 955 ret = iomap_file_buffered_write(iocb, from, &gfs2_iomap_ops); 956 current->backing_dev_info = NULL; 957 if (likely(ret > 0)) { 958 iocb->ki_pos += ret; 959 ret = generic_write_sync(iocb, ret); 960 } 961 } 962 963 out_unlock: 964 inode_unlock(inode); 965 return ret; 966 } 967 968 static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len, 969 int mode) 970 { 971 struct super_block *sb = inode->i_sb; 972 struct gfs2_inode *ip = GFS2_I(inode); 973 loff_t end = offset + len; 974 struct buffer_head *dibh; 975 int error; 976 977 error = gfs2_meta_inode_buffer(ip, &dibh); 978 if (unlikely(error)) 979 return error; 980 981 gfs2_trans_add_meta(ip->i_gl, dibh); 982 983 if (gfs2_is_stuffed(ip)) { 984 error = gfs2_unstuff_dinode(ip); 985 if (unlikely(error)) 986 goto out; 987 } 988 989 while (offset < end) { 990 struct iomap iomap = { }; 991 992 error = gfs2_iomap_alloc(inode, offset, end - offset, &iomap); 993 if (error) 994 goto out; 995 offset = iomap.offset + iomap.length; 996 if (!(iomap.flags & IOMAP_F_NEW)) 997 continue; 998 error = sb_issue_zeroout(sb, iomap.addr >> inode->i_blkbits, 999 iomap.length >> inode->i_blkbits, 1000 GFP_NOFS); 1001 if (error) { 1002 fs_err(GFS2_SB(inode), "Failed to zero data buffers\n"); 1003 goto out; 1004 } 1005 } 1006 out: 1007 brelse(dibh); 1008 return error; 1009 } 1010 1011 /** 1012 * calc_max_reserv() - Reverse of write_calc_reserv. Given a number of 1013 * blocks, determine how many bytes can be written. 1014 * @ip: The inode in question. 1015 * @len: Max cap of bytes. What we return in *len must be <= this. 1016 * @data_blocks: Compute and return the number of data blocks needed 1017 * @ind_blocks: Compute and return the number of indirect blocks needed 1018 * @max_blocks: The total blocks available to work with. 1019 * 1020 * Returns: void, but @len, @data_blocks and @ind_blocks are filled in. 1021 */ 1022 static void calc_max_reserv(struct gfs2_inode *ip, loff_t *len, 1023 unsigned int *data_blocks, unsigned int *ind_blocks, 1024 unsigned int max_blocks) 1025 { 1026 loff_t max = *len; 1027 const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1028 unsigned int tmp, max_data = max_blocks - 3 * (sdp->sd_max_height - 1); 1029 1030 for (tmp = max_data; tmp > sdp->sd_diptrs;) { 1031 tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs); 1032 max_data -= tmp; 1033 } 1034 1035 *data_blocks = max_data; 1036 *ind_blocks = max_blocks - max_data; 1037 *len = ((loff_t)max_data - 3) << sdp->sd_sb.sb_bsize_shift; 1038 if (*len > max) { 1039 *len = max; 1040 gfs2_write_calc_reserv(ip, max, data_blocks, ind_blocks); 1041 } 1042 } 1043 1044 static long __gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len) 1045 { 1046 struct inode *inode = file_inode(file); 1047 struct gfs2_sbd *sdp = GFS2_SB(inode); 1048 struct gfs2_inode *ip = GFS2_I(inode); 1049 struct gfs2_alloc_parms ap = { .aflags = 0, }; 1050 unsigned int data_blocks = 0, ind_blocks = 0, rblocks; 1051 loff_t bytes, max_bytes, max_blks; 1052 int error; 1053 const loff_t pos = offset; 1054 const loff_t count = len; 1055 loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1); 1056 loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift; 1057 loff_t max_chunk_size = UINT_MAX & bsize_mask; 1058 1059 next = (next + 1) << sdp->sd_sb.sb_bsize_shift; 1060 1061 offset &= bsize_mask; 1062 1063 len = next - offset; 1064 bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2; 1065 if (!bytes) 1066 bytes = UINT_MAX; 1067 bytes &= bsize_mask; 1068 if (bytes == 0) 1069 bytes = sdp->sd_sb.sb_bsize; 1070 1071 gfs2_size_hint(file, offset, len); 1072 1073 gfs2_write_calc_reserv(ip, PAGE_SIZE, &data_blocks, &ind_blocks); 1074 ap.min_target = data_blocks + ind_blocks; 1075 1076 while (len > 0) { 1077 if (len < bytes) 1078 bytes = len; 1079 if (!gfs2_write_alloc_required(ip, offset, bytes)) { 1080 len -= bytes; 1081 offset += bytes; 1082 continue; 1083 } 1084 1085 /* We need to determine how many bytes we can actually 1086 * fallocate without exceeding quota or going over the 1087 * end of the fs. We start off optimistically by assuming 1088 * we can write max_bytes */ 1089 max_bytes = (len > max_chunk_size) ? max_chunk_size : len; 1090 1091 /* Since max_bytes is most likely a theoretical max, we 1092 * calculate a more realistic 'bytes' to serve as a good 1093 * starting point for the number of bytes we may be able 1094 * to write */ 1095 gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks); 1096 ap.target = data_blocks + ind_blocks; 1097 1098 error = gfs2_quota_lock_check(ip, &ap); 1099 if (error) 1100 return error; 1101 /* ap.allowed tells us how many blocks quota will allow 1102 * us to write. Check if this reduces max_blks */ 1103 max_blks = UINT_MAX; 1104 if (ap.allowed) 1105 max_blks = ap.allowed; 1106 1107 error = gfs2_inplace_reserve(ip, &ap); 1108 if (error) 1109 goto out_qunlock; 1110 1111 /* check if the selected rgrp limits our max_blks further */ 1112 if (ip->i_res.rs_reserved < max_blks) 1113 max_blks = ip->i_res.rs_reserved; 1114 1115 /* Almost done. Calculate bytes that can be written using 1116 * max_blks. We also recompute max_bytes, data_blocks and 1117 * ind_blocks */ 1118 calc_max_reserv(ip, &max_bytes, &data_blocks, 1119 &ind_blocks, max_blks); 1120 1121 rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA + 1122 RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks); 1123 if (gfs2_is_jdata(ip)) 1124 rblocks += data_blocks ? data_blocks : 1; 1125 1126 error = gfs2_trans_begin(sdp, rblocks, 1127 PAGE_SIZE >> inode->i_blkbits); 1128 if (error) 1129 goto out_trans_fail; 1130 1131 error = fallocate_chunk(inode, offset, max_bytes, mode); 1132 gfs2_trans_end(sdp); 1133 1134 if (error) 1135 goto out_trans_fail; 1136 1137 len -= max_bytes; 1138 offset += max_bytes; 1139 gfs2_inplace_release(ip); 1140 gfs2_quota_unlock(ip); 1141 } 1142 1143 if (!(mode & FALLOC_FL_KEEP_SIZE) && (pos + count) > inode->i_size) 1144 i_size_write(inode, pos + count); 1145 file_update_time(file); 1146 mark_inode_dirty(inode); 1147 1148 if ((file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host)) 1149 return vfs_fsync_range(file, pos, pos + count - 1, 1150 (file->f_flags & __O_SYNC) ? 0 : 1); 1151 return 0; 1152 1153 out_trans_fail: 1154 gfs2_inplace_release(ip); 1155 out_qunlock: 1156 gfs2_quota_unlock(ip); 1157 return error; 1158 } 1159 1160 static long gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len) 1161 { 1162 struct inode *inode = file_inode(file); 1163 struct gfs2_sbd *sdp = GFS2_SB(inode); 1164 struct gfs2_inode *ip = GFS2_I(inode); 1165 struct gfs2_holder gh; 1166 int ret; 1167 1168 if (mode & ~(FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE)) 1169 return -EOPNOTSUPP; 1170 /* fallocate is needed by gfs2_grow to reserve space in the rindex */ 1171 if (gfs2_is_jdata(ip) && inode != sdp->sd_rindex) 1172 return -EOPNOTSUPP; 1173 1174 inode_lock(inode); 1175 1176 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 1177 ret = gfs2_glock_nq(&gh); 1178 if (ret) 1179 goto out_uninit; 1180 1181 if (!(mode & FALLOC_FL_KEEP_SIZE) && 1182 (offset + len) > inode->i_size) { 1183 ret = inode_newsize_ok(inode, offset + len); 1184 if (ret) 1185 goto out_unlock; 1186 } 1187 1188 ret = get_write_access(inode); 1189 if (ret) 1190 goto out_unlock; 1191 1192 if (mode & FALLOC_FL_PUNCH_HOLE) { 1193 ret = __gfs2_punch_hole(file, offset, len); 1194 } else { 1195 ret = __gfs2_fallocate(file, mode, offset, len); 1196 if (ret) 1197 gfs2_rs_deltree(&ip->i_res); 1198 } 1199 1200 put_write_access(inode); 1201 out_unlock: 1202 gfs2_glock_dq(&gh); 1203 out_uninit: 1204 gfs2_holder_uninit(&gh); 1205 inode_unlock(inode); 1206 return ret; 1207 } 1208 1209 static ssize_t gfs2_file_splice_write(struct pipe_inode_info *pipe, 1210 struct file *out, loff_t *ppos, 1211 size_t len, unsigned int flags) 1212 { 1213 ssize_t ret; 1214 1215 gfs2_size_hint(out, *ppos, len); 1216 1217 ret = iter_file_splice_write(pipe, out, ppos, len, flags); 1218 return ret; 1219 } 1220 1221 #ifdef CONFIG_GFS2_FS_LOCKING_DLM 1222 1223 /** 1224 * gfs2_lock - acquire/release a posix lock on a file 1225 * @file: the file pointer 1226 * @cmd: either modify or retrieve lock state, possibly wait 1227 * @fl: type and range of lock 1228 * 1229 * Returns: errno 1230 */ 1231 1232 static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl) 1233 { 1234 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host); 1235 struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host); 1236 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 1237 1238 if (!(fl->fl_flags & FL_POSIX)) 1239 return -ENOLCK; 1240 if (__mandatory_lock(&ip->i_inode) && fl->fl_type != F_UNLCK) 1241 return -ENOLCK; 1242 1243 if (cmd == F_CANCELLK) { 1244 /* Hack: */ 1245 cmd = F_SETLK; 1246 fl->fl_type = F_UNLCK; 1247 } 1248 if (unlikely(gfs2_withdrawn(sdp))) { 1249 if (fl->fl_type == F_UNLCK) 1250 locks_lock_file_wait(file, fl); 1251 return -EIO; 1252 } 1253 if (IS_GETLK(cmd)) 1254 return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl); 1255 else if (fl->fl_type == F_UNLCK) 1256 return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl); 1257 else 1258 return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl); 1259 } 1260 1261 static int do_flock(struct file *file, int cmd, struct file_lock *fl) 1262 { 1263 struct gfs2_file *fp = file->private_data; 1264 struct gfs2_holder *fl_gh = &fp->f_fl_gh; 1265 struct gfs2_inode *ip = GFS2_I(file_inode(file)); 1266 struct gfs2_glock *gl; 1267 unsigned int state; 1268 u16 flags; 1269 int error = 0; 1270 int sleeptime; 1271 1272 state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED; 1273 flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY_1CB) | GL_EXACT; 1274 1275 mutex_lock(&fp->f_fl_mutex); 1276 1277 if (gfs2_holder_initialized(fl_gh)) { 1278 struct file_lock request; 1279 if (fl_gh->gh_state == state) 1280 goto out; 1281 locks_init_lock(&request); 1282 request.fl_type = F_UNLCK; 1283 request.fl_flags = FL_FLOCK; 1284 locks_lock_file_wait(file, &request); 1285 gfs2_glock_dq(fl_gh); 1286 gfs2_holder_reinit(state, flags, fl_gh); 1287 } else { 1288 error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr, 1289 &gfs2_flock_glops, CREATE, &gl); 1290 if (error) 1291 goto out; 1292 gfs2_holder_init(gl, state, flags, fl_gh); 1293 gfs2_glock_put(gl); 1294 } 1295 for (sleeptime = 1; sleeptime <= 4; sleeptime <<= 1) { 1296 error = gfs2_glock_nq(fl_gh); 1297 if (error != GLR_TRYFAILED) 1298 break; 1299 fl_gh->gh_flags = LM_FLAG_TRY | GL_EXACT; 1300 fl_gh->gh_error = 0; 1301 msleep(sleeptime); 1302 } 1303 if (error) { 1304 gfs2_holder_uninit(fl_gh); 1305 if (error == GLR_TRYFAILED) 1306 error = -EAGAIN; 1307 } else { 1308 error = locks_lock_file_wait(file, fl); 1309 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error); 1310 } 1311 1312 out: 1313 mutex_unlock(&fp->f_fl_mutex); 1314 return error; 1315 } 1316 1317 static void do_unflock(struct file *file, struct file_lock *fl) 1318 { 1319 struct gfs2_file *fp = file->private_data; 1320 struct gfs2_holder *fl_gh = &fp->f_fl_gh; 1321 1322 mutex_lock(&fp->f_fl_mutex); 1323 locks_lock_file_wait(file, fl); 1324 if (gfs2_holder_initialized(fl_gh)) { 1325 gfs2_glock_dq(fl_gh); 1326 gfs2_holder_uninit(fl_gh); 1327 } 1328 mutex_unlock(&fp->f_fl_mutex); 1329 } 1330 1331 /** 1332 * gfs2_flock - acquire/release a flock lock on a file 1333 * @file: the file pointer 1334 * @cmd: either modify or retrieve lock state, possibly wait 1335 * @fl: type and range of lock 1336 * 1337 * Returns: errno 1338 */ 1339 1340 static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl) 1341 { 1342 if (!(fl->fl_flags & FL_FLOCK)) 1343 return -ENOLCK; 1344 if (fl->fl_type & LOCK_MAND) 1345 return -EOPNOTSUPP; 1346 1347 if (fl->fl_type == F_UNLCK) { 1348 do_unflock(file, fl); 1349 return 0; 1350 } else { 1351 return do_flock(file, cmd, fl); 1352 } 1353 } 1354 1355 const struct file_operations gfs2_file_fops = { 1356 .llseek = gfs2_llseek, 1357 .read_iter = gfs2_file_read_iter, 1358 .write_iter = gfs2_file_write_iter, 1359 .iopoll = iomap_dio_iopoll, 1360 .unlocked_ioctl = gfs2_ioctl, 1361 .compat_ioctl = gfs2_compat_ioctl, 1362 .mmap = gfs2_mmap, 1363 .open = gfs2_open, 1364 .release = gfs2_release, 1365 .fsync = gfs2_fsync, 1366 .lock = gfs2_lock, 1367 .flock = gfs2_flock, 1368 .splice_read = generic_file_splice_read, 1369 .splice_write = gfs2_file_splice_write, 1370 .setlease = simple_nosetlease, 1371 .fallocate = gfs2_fallocate, 1372 }; 1373 1374 const struct file_operations gfs2_dir_fops = { 1375 .iterate_shared = gfs2_readdir, 1376 .unlocked_ioctl = gfs2_ioctl, 1377 .compat_ioctl = gfs2_compat_ioctl, 1378 .open = gfs2_open, 1379 .release = gfs2_release, 1380 .fsync = gfs2_fsync, 1381 .lock = gfs2_lock, 1382 .flock = gfs2_flock, 1383 .llseek = default_llseek, 1384 }; 1385 1386 #endif /* CONFIG_GFS2_FS_LOCKING_DLM */ 1387 1388 const struct file_operations gfs2_file_fops_nolock = { 1389 .llseek = gfs2_llseek, 1390 .read_iter = gfs2_file_read_iter, 1391 .write_iter = gfs2_file_write_iter, 1392 .iopoll = iomap_dio_iopoll, 1393 .unlocked_ioctl = gfs2_ioctl, 1394 .compat_ioctl = gfs2_compat_ioctl, 1395 .mmap = gfs2_mmap, 1396 .open = gfs2_open, 1397 .release = gfs2_release, 1398 .fsync = gfs2_fsync, 1399 .splice_read = generic_file_splice_read, 1400 .splice_write = gfs2_file_splice_write, 1401 .setlease = generic_setlease, 1402 .fallocate = gfs2_fallocate, 1403 }; 1404 1405 const struct file_operations gfs2_dir_fops_nolock = { 1406 .iterate_shared = gfs2_readdir, 1407 .unlocked_ioctl = gfs2_ioctl, 1408 .compat_ioctl = gfs2_compat_ioctl, 1409 .open = gfs2_open, 1410 .release = gfs2_release, 1411 .fsync = gfs2_fsync, 1412 .llseek = default_llseek, 1413 }; 1414 1415