1 /* 2 * linux/fs/ext4/file.c 3 * 4 * Copyright (C) 1992, 1993, 1994, 1995 5 * Remy Card (card@masi.ibp.fr) 6 * Laboratoire MASI - Institut Blaise Pascal 7 * Universite Pierre et Marie Curie (Paris VI) 8 * 9 * from 10 * 11 * linux/fs/minix/file.c 12 * 13 * Copyright (C) 1991, 1992 Linus Torvalds 14 * 15 * ext4 fs regular file handling primitives 16 * 17 * 64-bit file support on 64-bit platforms by Jakub Jelinek 18 * (jj@sunsite.ms.mff.cuni.cz) 19 */ 20 21 #include <linux/time.h> 22 #include <linux/fs.h> 23 #include <linux/mount.h> 24 #include <linux/path.h> 25 #include <linux/dax.h> 26 #include <linux/quotaops.h> 27 #include <linux/pagevec.h> 28 #include <linux/uio.h> 29 #include "ext4.h" 30 #include "ext4_jbd2.h" 31 #include "xattr.h" 32 #include "acl.h" 33 34 /* 35 * Called when an inode is released. Note that this is different 36 * from ext4_file_open: open gets called at every open, but release 37 * gets called only when /all/ the files are closed. 38 */ 39 static int ext4_release_file(struct inode *inode, struct file *filp) 40 { 41 if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) { 42 ext4_alloc_da_blocks(inode); 43 ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE); 44 } 45 /* if we are the last writer on the inode, drop the block reservation */ 46 if ((filp->f_mode & FMODE_WRITE) && 47 (atomic_read(&inode->i_writecount) == 1) && 48 !EXT4_I(inode)->i_reserved_data_blocks) 49 { 50 down_write(&EXT4_I(inode)->i_data_sem); 51 ext4_discard_preallocations(inode); 52 up_write(&EXT4_I(inode)->i_data_sem); 53 } 54 if (is_dx(inode) && filp->private_data) 55 ext4_htree_free_dir_info(filp->private_data); 56 57 return 0; 58 } 59 60 static void ext4_unwritten_wait(struct inode *inode) 61 { 62 wait_queue_head_t *wq = ext4_ioend_wq(inode); 63 64 wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0)); 65 } 66 67 /* 68 * This tests whether the IO in question is block-aligned or not. 69 * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they 70 * are converted to written only after the IO is complete. Until they are 71 * mapped, these blocks appear as holes, so dio_zero_block() will assume that 72 * it needs to zero out portions of the start and/or end block. If 2 AIO 73 * threads are at work on the same unwritten block, they must be synchronized 74 * or one thread will zero the other's data, causing corruption. 75 */ 76 static int 77 ext4_unaligned_aio(struct inode *inode, struct iov_iter *from, loff_t pos) 78 { 79 struct super_block *sb = inode->i_sb; 80 int blockmask = sb->s_blocksize - 1; 81 82 if (pos >= i_size_read(inode)) 83 return 0; 84 85 if ((pos | iov_iter_alignment(from)) & blockmask) 86 return 1; 87 88 return 0; 89 } 90 91 static ssize_t 92 ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 93 { 94 struct file *file = iocb->ki_filp; 95 struct inode *inode = file_inode(iocb->ki_filp); 96 struct mutex *aio_mutex = NULL; 97 struct blk_plug plug; 98 int o_direct = iocb->ki_flags & IOCB_DIRECT; 99 int overwrite = 0; 100 ssize_t ret; 101 102 /* 103 * Unaligned direct AIO must be serialized; see comment above 104 * In the case of O_APPEND, assume that we must always serialize 105 */ 106 if (o_direct && 107 ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) && 108 !is_sync_kiocb(iocb) && 109 (iocb->ki_flags & IOCB_APPEND || 110 ext4_unaligned_aio(inode, from, iocb->ki_pos))) { 111 aio_mutex = ext4_aio_mutex(inode); 112 mutex_lock(aio_mutex); 113 ext4_unwritten_wait(inode); 114 } 115 116 inode_lock(inode); 117 ret = generic_write_checks(iocb, from); 118 if (ret <= 0) 119 goto out; 120 121 /* 122 * If we have encountered a bitmap-format file, the size limit 123 * is smaller than s_maxbytes, which is for extent-mapped files. 124 */ 125 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { 126 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 127 128 if (iocb->ki_pos >= sbi->s_bitmap_maxbytes) { 129 ret = -EFBIG; 130 goto out; 131 } 132 iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos); 133 } 134 135 iocb->private = &overwrite; 136 if (o_direct) { 137 size_t length = iov_iter_count(from); 138 loff_t pos = iocb->ki_pos; 139 blk_start_plug(&plug); 140 141 /* check whether we do a DIO overwrite or not */ 142 if (ext4_should_dioread_nolock(inode) && !aio_mutex && 143 !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) { 144 struct ext4_map_blocks map; 145 unsigned int blkbits = inode->i_blkbits; 146 int err, len; 147 148 map.m_lblk = pos >> blkbits; 149 map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits) 150 - map.m_lblk; 151 len = map.m_len; 152 153 err = ext4_map_blocks(NULL, inode, &map, 0); 154 /* 155 * 'err==len' means that all of blocks has 156 * been preallocated no matter they are 157 * initialized or not. For excluding 158 * unwritten extents, we need to check 159 * m_flags. There are two conditions that 160 * indicate for initialized extents. 1) If we 161 * hit extent cache, EXT4_MAP_MAPPED flag is 162 * returned; 2) If we do a real lookup, 163 * non-flags are returned. So we should check 164 * these two conditions. 165 */ 166 if (err == len && (map.m_flags & EXT4_MAP_MAPPED)) 167 overwrite = 1; 168 } 169 } 170 171 ret = __generic_file_write_iter(iocb, from); 172 inode_unlock(inode); 173 174 if (ret > 0) { 175 ssize_t err; 176 177 err = generic_write_sync(file, iocb->ki_pos - ret, ret); 178 if (err < 0) 179 ret = err; 180 } 181 if (o_direct) 182 blk_finish_plug(&plug); 183 184 if (aio_mutex) 185 mutex_unlock(aio_mutex); 186 return ret; 187 188 out: 189 inode_unlock(inode); 190 if (aio_mutex) 191 mutex_unlock(aio_mutex); 192 return ret; 193 } 194 195 #ifdef CONFIG_FS_DAX 196 static int ext4_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 197 { 198 int result; 199 handle_t *handle = NULL; 200 struct inode *inode = file_inode(vma->vm_file); 201 struct super_block *sb = inode->i_sb; 202 bool write = vmf->flags & FAULT_FLAG_WRITE; 203 204 if (write) { 205 sb_start_pagefault(sb); 206 file_update_time(vma->vm_file); 207 down_read(&EXT4_I(inode)->i_mmap_sem); 208 handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE, 209 EXT4_DATA_TRANS_BLOCKS(sb)); 210 } else 211 down_read(&EXT4_I(inode)->i_mmap_sem); 212 213 if (IS_ERR(handle)) 214 result = VM_FAULT_SIGBUS; 215 else 216 result = __dax_fault(vma, vmf, ext4_dax_mmap_get_block, NULL); 217 218 if (write) { 219 if (!IS_ERR(handle)) 220 ext4_journal_stop(handle); 221 up_read(&EXT4_I(inode)->i_mmap_sem); 222 sb_end_pagefault(sb); 223 } else 224 up_read(&EXT4_I(inode)->i_mmap_sem); 225 226 return result; 227 } 228 229 static int ext4_dax_pmd_fault(struct vm_area_struct *vma, unsigned long addr, 230 pmd_t *pmd, unsigned int flags) 231 { 232 int result; 233 handle_t *handle = NULL; 234 struct inode *inode = file_inode(vma->vm_file); 235 struct super_block *sb = inode->i_sb; 236 bool write = flags & FAULT_FLAG_WRITE; 237 238 if (write) { 239 sb_start_pagefault(sb); 240 file_update_time(vma->vm_file); 241 down_read(&EXT4_I(inode)->i_mmap_sem); 242 handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE, 243 ext4_chunk_trans_blocks(inode, 244 PMD_SIZE / PAGE_SIZE)); 245 } else 246 down_read(&EXT4_I(inode)->i_mmap_sem); 247 248 if (IS_ERR(handle)) 249 result = VM_FAULT_SIGBUS; 250 else 251 result = __dax_pmd_fault(vma, addr, pmd, flags, 252 ext4_dax_mmap_get_block, NULL); 253 254 if (write) { 255 if (!IS_ERR(handle)) 256 ext4_journal_stop(handle); 257 up_read(&EXT4_I(inode)->i_mmap_sem); 258 sb_end_pagefault(sb); 259 } else 260 up_read(&EXT4_I(inode)->i_mmap_sem); 261 262 return result; 263 } 264 265 /* 266 * Handle write fault for VM_MIXEDMAP mappings. Similarly to ext4_dax_fault() 267 * handler we check for races agaist truncate. Note that since we cycle through 268 * i_mmap_sem, we are sure that also any hole punching that began before we 269 * were called is finished by now and so if it included part of the file we 270 * are working on, our pte will get unmapped and the check for pte_same() in 271 * wp_pfn_shared() fails. Thus fault gets retried and things work out as 272 * desired. 273 */ 274 static int ext4_dax_pfn_mkwrite(struct vm_area_struct *vma, 275 struct vm_fault *vmf) 276 { 277 struct inode *inode = file_inode(vma->vm_file); 278 struct super_block *sb = inode->i_sb; 279 loff_t size; 280 int ret; 281 282 sb_start_pagefault(sb); 283 file_update_time(vma->vm_file); 284 down_read(&EXT4_I(inode)->i_mmap_sem); 285 size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT; 286 if (vmf->pgoff >= size) 287 ret = VM_FAULT_SIGBUS; 288 else 289 ret = dax_pfn_mkwrite(vma, vmf); 290 up_read(&EXT4_I(inode)->i_mmap_sem); 291 sb_end_pagefault(sb); 292 293 return ret; 294 } 295 296 static const struct vm_operations_struct ext4_dax_vm_ops = { 297 .fault = ext4_dax_fault, 298 .pmd_fault = ext4_dax_pmd_fault, 299 .page_mkwrite = ext4_dax_fault, 300 .pfn_mkwrite = ext4_dax_pfn_mkwrite, 301 }; 302 #else 303 #define ext4_dax_vm_ops ext4_file_vm_ops 304 #endif 305 306 static const struct vm_operations_struct ext4_file_vm_ops = { 307 .fault = ext4_filemap_fault, 308 .map_pages = filemap_map_pages, 309 .page_mkwrite = ext4_page_mkwrite, 310 }; 311 312 static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma) 313 { 314 struct inode *inode = file->f_mapping->host; 315 316 if (ext4_encrypted_inode(inode)) { 317 int err = ext4_get_encryption_info(inode); 318 if (err) 319 return 0; 320 if (ext4_encryption_info(inode) == NULL) 321 return -ENOKEY; 322 } 323 file_accessed(file); 324 if (IS_DAX(file_inode(file))) { 325 vma->vm_ops = &ext4_dax_vm_ops; 326 vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE; 327 } else { 328 vma->vm_ops = &ext4_file_vm_ops; 329 } 330 return 0; 331 } 332 333 static int ext4_file_open(struct inode * inode, struct file * filp) 334 { 335 struct super_block *sb = inode->i_sb; 336 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 337 struct vfsmount *mnt = filp->f_path.mnt; 338 struct inode *dir = filp->f_path.dentry->d_parent->d_inode; 339 struct path path; 340 char buf[64], *cp; 341 int ret; 342 343 if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) && 344 !(sb->s_flags & MS_RDONLY))) { 345 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED; 346 /* 347 * Sample where the filesystem has been mounted and 348 * store it in the superblock for sysadmin convenience 349 * when trying to sort through large numbers of block 350 * devices or filesystem images. 351 */ 352 memset(buf, 0, sizeof(buf)); 353 path.mnt = mnt; 354 path.dentry = mnt->mnt_root; 355 cp = d_path(&path, buf, sizeof(buf)); 356 if (!IS_ERR(cp)) { 357 handle_t *handle; 358 int err; 359 360 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1); 361 if (IS_ERR(handle)) 362 return PTR_ERR(handle); 363 BUFFER_TRACE(sbi->s_sbh, "get_write_access"); 364 err = ext4_journal_get_write_access(handle, sbi->s_sbh); 365 if (err) { 366 ext4_journal_stop(handle); 367 return err; 368 } 369 strlcpy(sbi->s_es->s_last_mounted, cp, 370 sizeof(sbi->s_es->s_last_mounted)); 371 ext4_handle_dirty_super(handle, sb); 372 ext4_journal_stop(handle); 373 } 374 } 375 if (ext4_encrypted_inode(inode)) { 376 ret = ext4_get_encryption_info(inode); 377 if (ret) 378 return -EACCES; 379 if (ext4_encryption_info(inode) == NULL) 380 return -ENOKEY; 381 } 382 if (ext4_encrypted_inode(dir) && 383 !ext4_is_child_context_consistent_with_parent(dir, inode)) { 384 ext4_warning(inode->i_sb, 385 "Inconsistent encryption contexts: %lu/%lu\n", 386 (unsigned long) dir->i_ino, 387 (unsigned long) inode->i_ino); 388 return -EPERM; 389 } 390 /* 391 * Set up the jbd2_inode if we are opening the inode for 392 * writing and the journal is present 393 */ 394 if (filp->f_mode & FMODE_WRITE) { 395 ret = ext4_inode_attach_jinode(inode); 396 if (ret < 0) 397 return ret; 398 } 399 return dquot_file_open(inode, filp); 400 } 401 402 /* 403 * Here we use ext4_map_blocks() to get a block mapping for a extent-based 404 * file rather than ext4_ext_walk_space() because we can introduce 405 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same 406 * function. When extent status tree has been fully implemented, it will 407 * track all extent status for a file and we can directly use it to 408 * retrieve the offset for SEEK_DATA/SEEK_HOLE. 409 */ 410 411 /* 412 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to 413 * lookup page cache to check whether or not there has some data between 414 * [startoff, endoff] because, if this range contains an unwritten extent, 415 * we determine this extent as a data or a hole according to whether the 416 * page cache has data or not. 417 */ 418 static int ext4_find_unwritten_pgoff(struct inode *inode, 419 int whence, 420 struct ext4_map_blocks *map, 421 loff_t *offset) 422 { 423 struct pagevec pvec; 424 unsigned int blkbits; 425 pgoff_t index; 426 pgoff_t end; 427 loff_t endoff; 428 loff_t startoff; 429 loff_t lastoff; 430 int found = 0; 431 432 blkbits = inode->i_sb->s_blocksize_bits; 433 startoff = *offset; 434 lastoff = startoff; 435 endoff = (loff_t)(map->m_lblk + map->m_len) << blkbits; 436 437 index = startoff >> PAGE_CACHE_SHIFT; 438 end = endoff >> PAGE_CACHE_SHIFT; 439 440 pagevec_init(&pvec, 0); 441 do { 442 int i, num; 443 unsigned long nr_pages; 444 445 num = min_t(pgoff_t, end - index, PAGEVEC_SIZE); 446 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index, 447 (pgoff_t)num); 448 if (nr_pages == 0) { 449 if (whence == SEEK_DATA) 450 break; 451 452 BUG_ON(whence != SEEK_HOLE); 453 /* 454 * If this is the first time to go into the loop and 455 * offset is not beyond the end offset, it will be a 456 * hole at this offset 457 */ 458 if (lastoff == startoff || lastoff < endoff) 459 found = 1; 460 break; 461 } 462 463 /* 464 * If this is the first time to go into the loop and 465 * offset is smaller than the first page offset, it will be a 466 * hole at this offset. 467 */ 468 if (lastoff == startoff && whence == SEEK_HOLE && 469 lastoff < page_offset(pvec.pages[0])) { 470 found = 1; 471 break; 472 } 473 474 for (i = 0; i < nr_pages; i++) { 475 struct page *page = pvec.pages[i]; 476 struct buffer_head *bh, *head; 477 478 /* 479 * If the current offset is not beyond the end of given 480 * range, it will be a hole. 481 */ 482 if (lastoff < endoff && whence == SEEK_HOLE && 483 page->index > end) { 484 found = 1; 485 *offset = lastoff; 486 goto out; 487 } 488 489 lock_page(page); 490 491 if (unlikely(page->mapping != inode->i_mapping)) { 492 unlock_page(page); 493 continue; 494 } 495 496 if (!page_has_buffers(page)) { 497 unlock_page(page); 498 continue; 499 } 500 501 if (page_has_buffers(page)) { 502 lastoff = page_offset(page); 503 bh = head = page_buffers(page); 504 do { 505 if (buffer_uptodate(bh) || 506 buffer_unwritten(bh)) { 507 if (whence == SEEK_DATA) 508 found = 1; 509 } else { 510 if (whence == SEEK_HOLE) 511 found = 1; 512 } 513 if (found) { 514 *offset = max_t(loff_t, 515 startoff, lastoff); 516 unlock_page(page); 517 goto out; 518 } 519 lastoff += bh->b_size; 520 bh = bh->b_this_page; 521 } while (bh != head); 522 } 523 524 lastoff = page_offset(page) + PAGE_SIZE; 525 unlock_page(page); 526 } 527 528 /* 529 * The no. of pages is less than our desired, that would be a 530 * hole in there. 531 */ 532 if (nr_pages < num && whence == SEEK_HOLE) { 533 found = 1; 534 *offset = lastoff; 535 break; 536 } 537 538 index = pvec.pages[i - 1]->index + 1; 539 pagevec_release(&pvec); 540 } while (index <= end); 541 542 out: 543 pagevec_release(&pvec); 544 return found; 545 } 546 547 /* 548 * ext4_seek_data() retrieves the offset for SEEK_DATA. 549 */ 550 static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize) 551 { 552 struct inode *inode = file->f_mapping->host; 553 struct ext4_map_blocks map; 554 struct extent_status es; 555 ext4_lblk_t start, last, end; 556 loff_t dataoff, isize; 557 int blkbits; 558 int ret = 0; 559 560 inode_lock(inode); 561 562 isize = i_size_read(inode); 563 if (offset >= isize) { 564 inode_unlock(inode); 565 return -ENXIO; 566 } 567 568 blkbits = inode->i_sb->s_blocksize_bits; 569 start = offset >> blkbits; 570 last = start; 571 end = isize >> blkbits; 572 dataoff = offset; 573 574 do { 575 map.m_lblk = last; 576 map.m_len = end - last + 1; 577 ret = ext4_map_blocks(NULL, inode, &map, 0); 578 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) { 579 if (last != start) 580 dataoff = (loff_t)last << blkbits; 581 break; 582 } 583 584 /* 585 * If there is a delay extent at this offset, 586 * it will be as a data. 587 */ 588 ext4_es_find_delayed_extent_range(inode, last, last, &es); 589 if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) { 590 if (last != start) 591 dataoff = (loff_t)last << blkbits; 592 break; 593 } 594 595 /* 596 * If there is a unwritten extent at this offset, 597 * it will be as a data or a hole according to page 598 * cache that has data or not. 599 */ 600 if (map.m_flags & EXT4_MAP_UNWRITTEN) { 601 int unwritten; 602 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA, 603 &map, &dataoff); 604 if (unwritten) 605 break; 606 } 607 608 last++; 609 dataoff = (loff_t)last << blkbits; 610 } while (last <= end); 611 612 inode_unlock(inode); 613 614 if (dataoff > isize) 615 return -ENXIO; 616 617 return vfs_setpos(file, dataoff, maxsize); 618 } 619 620 /* 621 * ext4_seek_hole() retrieves the offset for SEEK_HOLE. 622 */ 623 static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize) 624 { 625 struct inode *inode = file->f_mapping->host; 626 struct ext4_map_blocks map; 627 struct extent_status es; 628 ext4_lblk_t start, last, end; 629 loff_t holeoff, isize; 630 int blkbits; 631 int ret = 0; 632 633 inode_lock(inode); 634 635 isize = i_size_read(inode); 636 if (offset >= isize) { 637 inode_unlock(inode); 638 return -ENXIO; 639 } 640 641 blkbits = inode->i_sb->s_blocksize_bits; 642 start = offset >> blkbits; 643 last = start; 644 end = isize >> blkbits; 645 holeoff = offset; 646 647 do { 648 map.m_lblk = last; 649 map.m_len = end - last + 1; 650 ret = ext4_map_blocks(NULL, inode, &map, 0); 651 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) { 652 last += ret; 653 holeoff = (loff_t)last << blkbits; 654 continue; 655 } 656 657 /* 658 * If there is a delay extent at this offset, 659 * we will skip this extent. 660 */ 661 ext4_es_find_delayed_extent_range(inode, last, last, &es); 662 if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) { 663 last = es.es_lblk + es.es_len; 664 holeoff = (loff_t)last << blkbits; 665 continue; 666 } 667 668 /* 669 * If there is a unwritten extent at this offset, 670 * it will be as a data or a hole according to page 671 * cache that has data or not. 672 */ 673 if (map.m_flags & EXT4_MAP_UNWRITTEN) { 674 int unwritten; 675 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE, 676 &map, &holeoff); 677 if (!unwritten) { 678 last += ret; 679 holeoff = (loff_t)last << blkbits; 680 continue; 681 } 682 } 683 684 /* find a hole */ 685 break; 686 } while (last <= end); 687 688 inode_unlock(inode); 689 690 if (holeoff > isize) 691 holeoff = isize; 692 693 return vfs_setpos(file, holeoff, maxsize); 694 } 695 696 /* 697 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values 698 * by calling generic_file_llseek_size() with the appropriate maxbytes 699 * value for each. 700 */ 701 loff_t ext4_llseek(struct file *file, loff_t offset, int whence) 702 { 703 struct inode *inode = file->f_mapping->host; 704 loff_t maxbytes; 705 706 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 707 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes; 708 else 709 maxbytes = inode->i_sb->s_maxbytes; 710 711 switch (whence) { 712 case SEEK_SET: 713 case SEEK_CUR: 714 case SEEK_END: 715 return generic_file_llseek_size(file, offset, whence, 716 maxbytes, i_size_read(inode)); 717 case SEEK_DATA: 718 return ext4_seek_data(file, offset, maxbytes); 719 case SEEK_HOLE: 720 return ext4_seek_hole(file, offset, maxbytes); 721 } 722 723 return -EINVAL; 724 } 725 726 const struct file_operations ext4_file_operations = { 727 .llseek = ext4_llseek, 728 .read_iter = generic_file_read_iter, 729 .write_iter = ext4_file_write_iter, 730 .unlocked_ioctl = ext4_ioctl, 731 #ifdef CONFIG_COMPAT 732 .compat_ioctl = ext4_compat_ioctl, 733 #endif 734 .mmap = ext4_file_mmap, 735 .open = ext4_file_open, 736 .release = ext4_release_file, 737 .fsync = ext4_sync_file, 738 .splice_read = generic_file_splice_read, 739 .splice_write = iter_file_splice_write, 740 .fallocate = ext4_fallocate, 741 }; 742 743 const struct inode_operations ext4_file_inode_operations = { 744 .setattr = ext4_setattr, 745 .getattr = ext4_getattr, 746 .setxattr = generic_setxattr, 747 .getxattr = generic_getxattr, 748 .listxattr = ext4_listxattr, 749 .removexattr = generic_removexattr, 750 .get_acl = ext4_get_acl, 751 .set_acl = ext4_set_acl, 752 .fiemap = ext4_fiemap, 753 }; 754 755