LCOV - code coverage report
Current view: top level - lkbce/fs/ext2 - file.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 16 16 100.0 %
Date: 2017-01-25 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /*
       2             :  *  linux/fs/ext2/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             :  *  ext2 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/pagemap.h>
      23             : #include "ext2.h"
      24             : #include "xattr.h"
      25             : #include "acl.h"
      26             : 
      27             : /*
      28             :  * Called when filp is released. This happens when all file descriptors
      29             :  * for a single struct file are closed. Note that different open() calls
      30             :  * for the same file yield different struct file structures.
      31             :  */
      32             : static int ext2_release_file (struct inode * inode, struct file * filp)
      33             : {
      34           3 :         if (filp->f_mode & FMODE_WRITE) {
      35           4 :                 mutex_lock(&EXT2_I(inode)->truncate_mutex);
      36           4 :                 ext2_discard_reservation(inode);
      37           3 :                 mutex_unlock(&EXT2_I(inode)->truncate_mutex);
      38             :         }
      39           2 :         return 0;
      40             : }
      41             : 
      42             : int ext2_fsync(struct file *file, struct dentry *dentry, int datasync)
      43             : {
      44           2 :         int ret;
      45           4 :         struct super_block *sb = dentry->d_inode->i_sb;
      46           4 :         struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
      47           2 : 
      48           2 :         ret = simple_fsync(file, dentry, datasync);
      49          12 :         if (ret == -EIO || test_and_clear_bit(AS_EIO, &mapping->flags)) {
      50             :                 /* We don't really know where the IO error happened... */
      51          12 :                 ext2_error(sb, __func__,
      52             :                            "detected IO error when writing metadata buffers");
      53           4 :                 ret = -EIO;
      54             :         }
      55           6 :         return ret;
      56             : }
      57             : 
      58             : /*
      59             :  * We have mostly NULL's here: the current defaults are ok for
      60             :  * the ext2 filesystem.
      61             :  */
      62           1 : const struct file_operations ext2_file_operations = {
      63             :         .llseek         = generic_file_llseek,
      64             :         .read           = do_sync_read,
      65             :         .write          = do_sync_write,
      66             :         .aio_read       = generic_file_aio_read,
      67             :         .aio_write      = generic_file_aio_write,
      68             :         .unlocked_ioctl = ext2_ioctl,
      69             : #ifdef CONFIG_COMPAT
      70             :         .compat_ioctl   = ext2_compat_ioctl,
      71             : #endif
      72             :         .mmap           = generic_file_mmap,
      73             :         .open           = generic_file_open,
      74             :         .release        = ext2_release_file,
      75             :         .fsync          = ext2_fsync,
      76             :         .splice_read    = generic_file_splice_read,
      77             :         .splice_write   = generic_file_splice_write,
      78             : };
      79             : 
      80             : #ifdef CONFIG_EXT2_FS_XIP
      81             : const struct file_operations ext2_xip_file_operations = {
      82             :         .llseek         = generic_file_llseek,
      83             :         .read           = xip_file_read,
      84             :         .write          = xip_file_write,
      85             :         .unlocked_ioctl = ext2_ioctl,
      86             : #ifdef CONFIG_COMPAT
      87             :         .compat_ioctl   = ext2_compat_ioctl,
      88             : #endif
      89             :         .mmap           = xip_file_mmap,
      90             :         .open           = generic_file_open,
      91             :         .release        = ext2_release_file,
      92             :         .fsync          = ext2_fsync,
      93             : };
      94             : #endif
      95             : 
      96           1 : const struct inode_operations ext2_file_inode_operations = {
      97             :         .truncate       = ext2_truncate,
      98             : #ifdef CONFIG_EXT2_FS_XATTR
      99             :         .setxattr       = generic_setxattr,
     100             :         .getxattr       = generic_getxattr,
     101             :         .listxattr      = ext2_listxattr,
     102             :         .removexattr    = generic_removexattr,
     103             : #endif
     104             :         .setattr        = ext2_setattr,
     105             :         .check_acl      = ext2_check_acl,
     106             :         .fiemap         = ext2_fiemap,
     107             : };

Generated by: LCOV version 1.10