LCOV - code coverage report
Current view: top level - fs/ext4 - file.c (source / functions) Hit Total Coverage
Test: Real Lines: 82 117 70.1 %
Date: 2020-10-17 15:46:16 Functions: 0 11 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *  linux/fs/ext4/file.c
       4                 :            :  *
       5                 :            :  * Copyright (C) 1992, 1993, 1994, 1995
       6                 :            :  * Remy Card (card@masi.ibp.fr)
       7                 :            :  * Laboratoire MASI - Institut Blaise Pascal
       8                 :            :  * Universite Pierre et Marie Curie (Paris VI)
       9                 :            :  *
      10                 :            :  *  from
      11                 :            :  *
      12                 :            :  *  linux/fs/minix/file.c
      13                 :            :  *
      14                 :            :  *  Copyright (C) 1991, 1992  Linus Torvalds
      15                 :            :  *
      16                 :            :  *  ext4 fs regular file handling primitives
      17                 :            :  *
      18                 :            :  *  64-bit file support on 64-bit platforms by Jakub Jelinek
      19                 :            :  *      (jj@sunsite.ms.mff.cuni.cz)
      20                 :            :  */
      21                 :            : 
      22                 :            : #include <linux/time.h>
      23                 :            : #include <linux/fs.h>
      24                 :            : #include <linux/iomap.h>
      25                 :            : #include <linux/mount.h>
      26                 :            : #include <linux/path.h>
      27                 :            : #include <linux/dax.h>
      28                 :            : #include <linux/quotaops.h>
      29                 :            : #include <linux/pagevec.h>
      30                 :            : #include <linux/uio.h>
      31                 :            : #include <linux/mman.h>
      32                 :            : #include "ext4.h"
      33                 :            : #include "ext4_jbd2.h"
      34                 :            : #include "xattr.h"
      35                 :            : #include "acl.h"
      36                 :            : 
      37                 :            : #ifdef CONFIG_FS_DAX
      38                 :            : static ssize_t ext4_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
      39                 :            : {
      40                 :            :         struct inode *inode = file_inode(iocb->ki_filp);
      41                 :            :         ssize_t ret;
      42                 :            : 
      43                 :            :         if (iocb->ki_flags & IOCB_NOWAIT) {
      44                 :            :                 if (!inode_trylock_shared(inode))
      45                 :            :                         return -EAGAIN;
      46                 :            :         } else {
      47                 :            :                 inode_lock_shared(inode);
      48                 :            :         }
      49                 :            :         /*
      50                 :            :          * Recheck under inode lock - at this point we are sure it cannot
      51                 :            :          * change anymore
      52                 :            :          */
      53                 :            :         if (!IS_DAX(inode)) {
      54                 :            :                 inode_unlock_shared(inode);
      55                 :            :                 /* Fallback to buffered IO in case we cannot support DAX */
      56                 :            :                 return generic_file_read_iter(iocb, to);
      57                 :            :         }
      58                 :            :         ret = dax_iomap_rw(iocb, to, &ext4_iomap_ops);
      59                 :            :         inode_unlock_shared(inode);
      60                 :            : 
      61                 :            :         file_accessed(iocb->ki_filp);
      62                 :            :         return ret;
      63                 :            : }
      64                 :            : #endif
      65                 :            : 
      66                 :          3 : static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
      67                 :            : {
      68                 :          3 :         if (unlikely(ext4_forced_shutdown(EXT4_SB(file_inode(iocb->ki_filp)->i_sb))))
      69                 :            :                 return -EIO;
      70                 :            : 
      71                 :          3 :         if (!iov_iter_count(to))
      72                 :            :                 return 0; /* skip atime */
      73                 :            : 
      74                 :            : #ifdef CONFIG_FS_DAX
      75                 :            :         if (IS_DAX(file_inode(iocb->ki_filp)))
      76                 :            :                 return ext4_dax_read_iter(iocb, to);
      77                 :            : #endif
      78                 :          3 :         return generic_file_read_iter(iocb, to);
      79                 :            : }
      80                 :            : 
      81                 :            : /*
      82                 :            :  * Called when an inode is released. Note that this is different
      83                 :            :  * from ext4_file_open: open gets called at every open, but release
      84                 :            :  * gets called only when /all/ the files are closed.
      85                 :            :  */
      86                 :          3 : static int ext4_release_file(struct inode *inode, struct file *filp)
      87                 :            : {
      88                 :          3 :         if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
      89                 :          3 :                 ext4_alloc_da_blocks(inode);
      90                 :            :                 ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
      91                 :            :         }
      92                 :            :         /* if we are the last writer on the inode, drop the block reservation */
      93                 :          3 :         if ((filp->f_mode & FMODE_WRITE) &&
      94                 :          3 :                         (atomic_read(&inode->i_writecount) == 1) &&
      95                 :          3 :                         !EXT4_I(inode)->i_reserved_data_blocks)
      96                 :            :         {
      97                 :          3 :                 down_write(&EXT4_I(inode)->i_data_sem);
      98                 :          3 :                 ext4_discard_preallocations(inode);
      99                 :          3 :                 up_write(&EXT4_I(inode)->i_data_sem);
     100                 :            :         }
     101                 :          3 :         if (is_dx(inode) && filp->private_data)
     102                 :          0 :                 ext4_htree_free_dir_info(filp->private_data);
     103                 :            : 
     104                 :          3 :         return 0;
     105                 :            : }
     106                 :            : 
     107                 :          0 : static void ext4_unwritten_wait(struct inode *inode)
     108                 :            : {
     109                 :          0 :         wait_queue_head_t *wq = ext4_ioend_wq(inode);
     110                 :            : 
     111                 :          0 :         wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0));
     112                 :          0 : }
     113                 :            : 
     114                 :            : /*
     115                 :            :  * This tests whether the IO in question is block-aligned or not.
     116                 :            :  * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they
     117                 :            :  * are converted to written only after the IO is complete.  Until they are
     118                 :            :  * mapped, these blocks appear as holes, so dio_zero_block() will assume that
     119                 :            :  * it needs to zero out portions of the start and/or end block.  If 2 AIO
     120                 :            :  * threads are at work on the same unwritten block, they must be synchronized
     121                 :            :  * or one thread will zero the other's data, causing corruption.
     122                 :            :  */
     123                 :            : static int
     124                 :          0 : ext4_unaligned_aio(struct inode *inode, struct iov_iter *from, loff_t pos)
     125                 :            : {
     126                 :          0 :         struct super_block *sb = inode->i_sb;
     127                 :          0 :         int blockmask = sb->s_blocksize - 1;
     128                 :            : 
     129                 :          0 :         if (pos >= ALIGN(i_size_read(inode), sb->s_blocksize))
     130                 :            :                 return 0;
     131                 :            : 
     132                 :          0 :         if ((pos | iov_iter_alignment(from)) & blockmask)
     133                 :            :                 return 1;
     134                 :            : 
     135                 :          0 :         return 0;
     136                 :            : }
     137                 :            : 
     138                 :            : /* Is IO overwriting allocated and initialized blocks? */
     139                 :          0 : static bool ext4_overwrite_io(struct inode *inode, loff_t pos, loff_t len)
     140                 :            : {
     141                 :            :         struct ext4_map_blocks map;
     142                 :          0 :         unsigned int blkbits = inode->i_blkbits;
     143                 :            :         int err, blklen;
     144                 :            : 
     145                 :          0 :         if (pos + len > i_size_read(inode))
     146                 :            :                 return false;
     147                 :            : 
     148                 :          0 :         map.m_lblk = pos >> blkbits;
     149                 :          0 :         map.m_len = EXT4_MAX_BLOCKS(len, pos, blkbits);
     150                 :          0 :         blklen = map.m_len;
     151                 :            : 
     152                 :          0 :         err = ext4_map_blocks(NULL, inode, &map, 0);
     153                 :            :         /*
     154                 :            :          * 'err==len' means that all of the blocks have been preallocated,
     155                 :            :          * regardless of whether they have been initialized or not. To exclude
     156                 :            :          * unwritten extents, we need to check m_flags.
     157                 :            :          */
     158                 :          0 :         return err == blklen && (map.m_flags & EXT4_MAP_MAPPED);
     159                 :            : }
     160                 :            : 
     161                 :          3 : static ssize_t ext4_write_checks(struct kiocb *iocb, struct iov_iter *from)
     162                 :            : {
     163                 :          3 :         struct inode *inode = file_inode(iocb->ki_filp);
     164                 :            :         ssize_t ret;
     165                 :            : 
     166                 :          3 :         ret = generic_write_checks(iocb, from);
     167                 :          3 :         if (ret <= 0)
     168                 :            :                 return ret;
     169                 :            : 
     170                 :          3 :         if (unlikely(IS_IMMUTABLE(inode)))
     171                 :            :                 return -EPERM;
     172                 :            : 
     173                 :            :         /*
     174                 :            :          * If we have encountered a bitmap-format file, the size limit
     175                 :            :          * is smaller than s_maxbytes, which is for extent-mapped files.
     176                 :            :          */
     177                 :          3 :         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
     178                 :          0 :                 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
     179                 :            : 
     180                 :          0 :                 if (iocb->ki_pos >= sbi->s_bitmap_maxbytes)
     181                 :            :                         return -EFBIG;
     182                 :          0 :                 iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);
     183                 :            :         }
     184                 :          3 :         return iov_iter_count(from);
     185                 :            : }
     186                 :            : 
     187                 :            : #ifdef CONFIG_FS_DAX
     188                 :            : static ssize_t
     189                 :            : ext4_dax_write_iter(struct kiocb *iocb, struct iov_iter *from)
     190                 :            : {
     191                 :            :         struct inode *inode = file_inode(iocb->ki_filp);
     192                 :            :         ssize_t ret;
     193                 :            : 
     194                 :            :         if (iocb->ki_flags & IOCB_NOWAIT) {
     195                 :            :                 if (!inode_trylock(inode))
     196                 :            :                         return -EAGAIN;
     197                 :            :         } else {
     198                 :            :                 inode_lock(inode);
     199                 :            :         }
     200                 :            :         ret = ext4_write_checks(iocb, from);
     201                 :            :         if (ret <= 0)
     202                 :            :                 goto out;
     203                 :            :         ret = file_remove_privs(iocb->ki_filp);
     204                 :            :         if (ret)
     205                 :            :                 goto out;
     206                 :            :         ret = file_update_time(iocb->ki_filp);
     207                 :            :         if (ret)
     208                 :            :                 goto out;
     209                 :            : 
     210                 :            :         ret = dax_iomap_rw(iocb, from, &ext4_iomap_ops);
     211                 :            : out:
     212                 :            :         inode_unlock(inode);
     213                 :            :         if (ret > 0)
     214                 :            :                 ret = generic_write_sync(iocb, ret);
     215                 :            :         return ret;
     216                 :            : }
     217                 :            : #endif
     218                 :            : 
     219                 :            : static ssize_t
     220                 :          3 : ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
     221                 :            : {
     222                 :          3 :         struct inode *inode = file_inode(iocb->ki_filp);
     223                 :          3 :         int o_direct = iocb->ki_flags & IOCB_DIRECT;
     224                 :            :         int unaligned_aio = 0;
     225                 :          3 :         int overwrite = 0;
     226                 :            :         ssize_t ret;
     227                 :            : 
     228                 :          3 :         if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
     229                 :            :                 return -EIO;
     230                 :            : 
     231                 :            : #ifdef CONFIG_FS_DAX
     232                 :            :         if (IS_DAX(inode))
     233                 :            :                 return ext4_dax_write_iter(iocb, from);
     234                 :            : #endif
     235                 :            : 
     236                 :          3 :         if (!inode_trylock(inode)) {
     237                 :          0 :                 if (iocb->ki_flags & IOCB_NOWAIT)
     238                 :            :                         return -EAGAIN;
     239                 :            :                 inode_lock(inode);
     240                 :            :         }
     241                 :            : 
     242                 :          3 :         ret = ext4_write_checks(iocb, from);
     243                 :          3 :         if (ret <= 0)
     244                 :            :                 goto out;
     245                 :            : 
     246                 :            :         /*
     247                 :            :          * Unaligned direct AIO must be serialized among each other as zeroing
     248                 :            :          * of partial blocks of two competing unaligned AIOs can result in data
     249                 :            :          * corruption.
     250                 :            :          */
     251                 :          3 :         if (o_direct && ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
     252                 :          0 :             !is_sync_kiocb(iocb) &&
     253                 :          0 :             ext4_unaligned_aio(inode, from, iocb->ki_pos)) {
     254                 :            :                 unaligned_aio = 1;
     255                 :          0 :                 ext4_unwritten_wait(inode);
     256                 :            :         }
     257                 :            : 
     258                 :          3 :         iocb->private = &overwrite;
     259                 :            :         /* Check whether we do a DIO overwrite or not */
     260                 :          3 :         if (o_direct && !unaligned_aio) {
     261                 :          0 :                 if (ext4_overwrite_io(inode, iocb->ki_pos, iov_iter_count(from))) {
     262                 :          0 :                         if (ext4_should_dioread_nolock(inode))
     263                 :          0 :                                 overwrite = 1;
     264                 :          0 :                 } else if (iocb->ki_flags & IOCB_NOWAIT) {
     265                 :            :                         ret = -EAGAIN;
     266                 :            :                         goto out;
     267                 :            :                 }
     268                 :            :         }
     269                 :            : 
     270                 :          3 :         ret = __generic_file_write_iter(iocb, from);
     271                 :            :         /*
     272                 :            :          * Unaligned direct AIO must be the only IO in flight. Otherwise
     273                 :            :          * overlapping aligned IO after unaligned might result in data
     274                 :            :          * corruption.
     275                 :            :          */
     276                 :          3 :         if (ret == -EIOCBQUEUED && unaligned_aio)
     277                 :          0 :                 ext4_unwritten_wait(inode);
     278                 :            :         inode_unlock(inode);
     279                 :            : 
     280                 :          3 :         if (ret > 0)
     281                 :          3 :                 ret = generic_write_sync(iocb, ret);
     282                 :            : 
     283                 :          3 :         return ret;
     284                 :            : 
     285                 :            : out:
     286                 :            :         inode_unlock(inode);
     287                 :          3 :         return ret;
     288                 :            : }
     289                 :            : 
     290                 :            : #ifdef CONFIG_FS_DAX
     291                 :            : static vm_fault_t ext4_dax_huge_fault(struct vm_fault *vmf,
     292                 :            :                 enum page_entry_size pe_size)
     293                 :            : {
     294                 :            :         int error = 0;
     295                 :            :         vm_fault_t result;
     296                 :            :         int retries = 0;
     297                 :            :         handle_t *handle = NULL;
     298                 :            :         struct inode *inode = file_inode(vmf->vma->vm_file);
     299                 :            :         struct super_block *sb = inode->i_sb;
     300                 :            : 
     301                 :            :         /*
     302                 :            :          * We have to distinguish real writes from writes which will result in a
     303                 :            :          * COW page; COW writes should *not* poke the journal (the file will not
     304                 :            :          * be changed). Doing so would cause unintended failures when mounted
     305                 :            :          * read-only.
     306                 :            :          *
     307                 :            :          * We check for VM_SHARED rather than vmf->cow_page since the latter is
     308                 :            :          * unset for pe_size != PE_SIZE_PTE (i.e. only in do_cow_fault); for
     309                 :            :          * other sizes, dax_iomap_fault will handle splitting / fallback so that
     310                 :            :          * we eventually come back with a COW page.
     311                 :            :          */
     312                 :            :         bool write = (vmf->flags & FAULT_FLAG_WRITE) &&
     313                 :            :                 (vmf->vma->vm_flags & VM_SHARED);
     314                 :            :         pfn_t pfn;
     315                 :            : 
     316                 :            :         if (write) {
     317                 :            :                 sb_start_pagefault(sb);
     318                 :            :                 file_update_time(vmf->vma->vm_file);
     319                 :            :                 down_read(&EXT4_I(inode)->i_mmap_sem);
     320                 :            : retry:
     321                 :            :                 handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
     322                 :            :                                                EXT4_DATA_TRANS_BLOCKS(sb));
     323                 :            :                 if (IS_ERR(handle)) {
     324                 :            :                         up_read(&EXT4_I(inode)->i_mmap_sem);
     325                 :            :                         sb_end_pagefault(sb);
     326                 :            :                         return VM_FAULT_SIGBUS;
     327                 :            :                 }
     328                 :            :         } else {
     329                 :            :                 down_read(&EXT4_I(inode)->i_mmap_sem);
     330                 :            :         }
     331                 :            :         result = dax_iomap_fault(vmf, pe_size, &pfn, &error, &ext4_iomap_ops);
     332                 :            :         if (write) {
     333                 :            :                 ext4_journal_stop(handle);
     334                 :            : 
     335                 :            :                 if ((result & VM_FAULT_ERROR) && error == -ENOSPC &&
     336                 :            :                     ext4_should_retry_alloc(sb, &retries))
     337                 :            :                         goto retry;
     338                 :            :                 /* Handling synchronous page fault? */
     339                 :            :                 if (result & VM_FAULT_NEEDDSYNC)
     340                 :            :                         result = dax_finish_sync_fault(vmf, pe_size, pfn);
     341                 :            :                 up_read(&EXT4_I(inode)->i_mmap_sem);
     342                 :            :                 sb_end_pagefault(sb);
     343                 :            :         } else {
     344                 :            :                 up_read(&EXT4_I(inode)->i_mmap_sem);
     345                 :            :         }
     346                 :            : 
     347                 :            :         return result;
     348                 :            : }
     349                 :            : 
     350                 :            : static vm_fault_t ext4_dax_fault(struct vm_fault *vmf)
     351                 :            : {
     352                 :            :         return ext4_dax_huge_fault(vmf, PE_SIZE_PTE);
     353                 :            : }
     354                 :            : 
     355                 :            : static const struct vm_operations_struct ext4_dax_vm_ops = {
     356                 :            :         .fault          = ext4_dax_fault,
     357                 :            :         .huge_fault     = ext4_dax_huge_fault,
     358                 :            :         .page_mkwrite   = ext4_dax_fault,
     359                 :            :         .pfn_mkwrite    = ext4_dax_fault,
     360                 :            : };
     361                 :            : #else
     362                 :            : #define ext4_dax_vm_ops ext4_file_vm_ops
     363                 :            : #endif
     364                 :            : 
     365                 :            : static const struct vm_operations_struct ext4_file_vm_ops = {
     366                 :            :         .fault          = ext4_filemap_fault,
     367                 :            :         .map_pages      = filemap_map_pages,
     368                 :            :         .page_mkwrite   = ext4_page_mkwrite,
     369                 :            : };
     370                 :            : 
     371                 :          3 : static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
     372                 :            : {
     373                 :          3 :         struct inode *inode = file->f_mapping->host;
     374                 :          3 :         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
     375                 :            :         struct dax_device *dax_dev = sbi->s_daxdev;
     376                 :            : 
     377                 :          3 :         if (unlikely(ext4_forced_shutdown(sbi)))
     378                 :            :                 return -EIO;
     379                 :            : 
     380                 :            :         /*
     381                 :            :          * We don't support synchronous mappings for non-DAX files and
     382                 :            :          * for DAX files if underneath dax_device is not synchronous.
     383                 :            :          */
     384                 :          3 :         if (!daxdev_mapping_supported(vma, dax_dev))
     385                 :            :                 return -EOPNOTSUPP;
     386                 :            : 
     387                 :            :         file_accessed(file);
     388                 :            :         if (IS_DAX(file_inode(file))) {
     389                 :            :                 vma->vm_ops = &ext4_dax_vm_ops;
     390                 :            :                 vma->vm_flags |= VM_HUGEPAGE;
     391                 :            :         } else {
     392                 :          3 :                 vma->vm_ops = &ext4_file_vm_ops;
     393                 :            :         }
     394                 :          3 :         return 0;
     395                 :            : }
     396                 :            : 
     397                 :          3 : static int ext4_sample_last_mounted(struct super_block *sb,
     398                 :            :                                     struct vfsmount *mnt)
     399                 :            : {
     400                 :            :         struct ext4_sb_info *sbi = EXT4_SB(sb);
     401                 :            :         struct path path;
     402                 :            :         char buf[64], *cp;
     403                 :            :         handle_t *handle;
     404                 :            :         int err;
     405                 :            : 
     406                 :          3 :         if (likely(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED))
     407                 :            :                 return 0;
     408                 :            : 
     409                 :          3 :         if (sb_rdonly(sb) || !sb_start_intwrite_trylock(sb))
     410                 :            :                 return 0;
     411                 :            : 
     412                 :          3 :         sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
     413                 :            :         /*
     414                 :            :          * Sample where the filesystem has been mounted and
     415                 :            :          * store it in the superblock for sysadmin convenience
     416                 :            :          * when trying to sort through large numbers of block
     417                 :            :          * devices or filesystem images.
     418                 :            :          */
     419                 :          3 :         memset(buf, 0, sizeof(buf));
     420                 :          3 :         path.mnt = mnt;
     421                 :          3 :         path.dentry = mnt->mnt_root;
     422                 :          3 :         cp = d_path(&path, buf, sizeof(buf));
     423                 :            :         err = 0;
     424                 :          3 :         if (IS_ERR(cp))
     425                 :            :                 goto out;
     426                 :            : 
     427                 :          3 :         handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
     428                 :            :         err = PTR_ERR(handle);
     429                 :          3 :         if (IS_ERR(handle))
     430                 :            :                 goto out;
     431                 :            :         BUFFER_TRACE(sbi->s_sbh, "get_write_access");
     432                 :          3 :         err = ext4_journal_get_write_access(handle, sbi->s_sbh);
     433                 :          3 :         if (err)
     434                 :            :                 goto out_journal;
     435                 :          3 :         strlcpy(sbi->s_es->s_last_mounted, cp,
     436                 :            :                 sizeof(sbi->s_es->s_last_mounted));
     437                 :          3 :         ext4_handle_dirty_super(handle, sb);
     438                 :            : out_journal:
     439                 :          3 :         ext4_journal_stop(handle);
     440                 :            : out:
     441                 :            :         sb_end_intwrite(sb);
     442                 :          3 :         return err;
     443                 :            : }
     444                 :            : 
     445                 :          3 : static int ext4_file_open(struct inode * inode, struct file * filp)
     446                 :            : {
     447                 :            :         int ret;
     448                 :            : 
     449                 :          3 :         if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
     450                 :            :                 return -EIO;
     451                 :            : 
     452                 :          3 :         ret = ext4_sample_last_mounted(inode->i_sb, filp->f_path.mnt);
     453                 :          3 :         if (ret)
     454                 :            :                 return ret;
     455                 :            : 
     456                 :          3 :         ret = fscrypt_file_open(inode, filp);
     457                 :          3 :         if (ret)
     458                 :            :                 return ret;
     459                 :            : 
     460                 :            :         ret = fsverity_file_open(inode, filp);
     461                 :          3 :         if (ret)
     462                 :            :                 return ret;
     463                 :            : 
     464                 :            :         /*
     465                 :            :          * Set up the jbd2_inode if we are opening the inode for
     466                 :            :          * writing and the journal is present
     467                 :            :          */
     468                 :          3 :         if (filp->f_mode & FMODE_WRITE) {
     469                 :          3 :                 ret = ext4_inode_attach_jinode(inode);
     470                 :          3 :                 if (ret < 0)
     471                 :            :                         return ret;
     472                 :            :         }
     473                 :            : 
     474                 :          3 :         filp->f_mode |= FMODE_NOWAIT;
     475                 :          3 :         return dquot_file_open(inode, filp);
     476                 :            : }
     477                 :            : 
     478                 :            : /*
     479                 :            :  * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
     480                 :            :  * by calling generic_file_llseek_size() with the appropriate maxbytes
     481                 :            :  * value for each.
     482                 :            :  */
     483                 :          3 : loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
     484                 :            : {
     485                 :          3 :         struct inode *inode = file->f_mapping->host;
     486                 :            :         loff_t maxbytes;
     487                 :            : 
     488                 :          3 :         if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
     489                 :          2 :                 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
     490                 :            :         else
     491                 :          3 :                 maxbytes = inode->i_sb->s_maxbytes;
     492                 :            : 
     493                 :          3 :         switch (whence) {
     494                 :            :         default:
     495                 :          3 :                 return generic_file_llseek_size(file, offset, whence,
     496                 :            :                                                 maxbytes, i_size_read(inode));
     497                 :            :         case SEEK_HOLE:
     498                 :            :                 inode_lock_shared(inode);
     499                 :          0 :                 offset = iomap_seek_hole(inode, offset, &ext4_iomap_ops);
     500                 :            :                 inode_unlock_shared(inode);
     501                 :            :                 break;
     502                 :            :         case SEEK_DATA:
     503                 :            :                 inode_lock_shared(inode);
     504                 :          0 :                 offset = iomap_seek_data(inode, offset, &ext4_iomap_ops);
     505                 :            :                 inode_unlock_shared(inode);
     506                 :            :                 break;
     507                 :            :         }
     508                 :            : 
     509                 :          0 :         if (offset < 0)
     510                 :            :                 return offset;
     511                 :          0 :         return vfs_setpos(file, offset, maxbytes);
     512                 :            : }
     513                 :            : 
     514                 :            : const struct file_operations ext4_file_operations = {
     515                 :            :         .llseek         = ext4_llseek,
     516                 :            :         .read_iter      = ext4_file_read_iter,
     517                 :            :         .write_iter     = ext4_file_write_iter,
     518                 :            :         .unlocked_ioctl = ext4_ioctl,
     519                 :            : #ifdef CONFIG_COMPAT
     520                 :            :         .compat_ioctl   = ext4_compat_ioctl,
     521                 :            : #endif
     522                 :            :         .mmap           = ext4_file_mmap,
     523                 :            :         .mmap_supported_flags = MAP_SYNC,
     524                 :            :         .open           = ext4_file_open,
     525                 :            :         .release        = ext4_release_file,
     526                 :            :         .fsync          = ext4_sync_file,
     527                 :            :         .get_unmapped_area = thp_get_unmapped_area,
     528                 :            :         .splice_read    = generic_file_splice_read,
     529                 :            :         .splice_write   = iter_file_splice_write,
     530                 :            :         .fallocate      = ext4_fallocate,
     531                 :            : };
     532                 :            : 
     533                 :            : const struct inode_operations ext4_file_inode_operations = {
     534                 :            :         .setattr        = ext4_setattr,
     535                 :            :         .getattr        = ext4_file_getattr,
     536                 :            :         .listxattr      = ext4_listxattr,
     537                 :            :         .get_acl        = ext4_get_acl,
     538                 :            :         .set_acl        = ext4_set_acl,
     539                 :            :         .fiemap         = ext4_fiemap,
     540                 :            : };
     541                 :            : 
    

Generated by: LCOV version 1.14