file.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*
    2  *  linux/fs/ext3/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  *  ext3 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/sched.h>
   22 #include <linux/fs.h>
   23 #include <linux/locks.h>
   24 #include <linux/jbd.h>
   25 #include <linux/ext3_fs.h>
   26 #include <linux/ext3_jbd.h>
   27 #include <linux/smp_lock.h>
   28 
   29 /*
   30  * Called when an inode is released. Note that this is different
   31  * from ext3_file_open: open gets called at every open, but release
   32  * gets called only when /all/ the files are closed.
   33  */
   34 static int ext3_release_file (struct inode * inode, struct file * filp)
   35 {
   36         if (filp->f_mode & FMODE_WRITE)
   37                 ext3_discard_prealloc (inode);
   38         return 0;
   39 }
   40 
   41 /*
   42  * Called when an inode is about to be opened.
   43  * We use this to disallow opening RW large files on 32bit systems if
   44  * the caller didn't specify O_LARGEFILE.  On 64bit systems we force
   45  * on this flag in sys_open.
   46  */
   47 static int ext3_open_file (struct inode * inode, struct file * filp)
   48 {
   49         if (!(filp->f_flags & O_LARGEFILE) &&
   50             inode->i_size > 0x7FFFFFFFLL)
   51                 return -EFBIG;
   52         return 0;
   53 }
   54 
   55 /*
   56  * ext3_file_write().
   57  *
   58  * Most things are done in ext3_prepare_write() and ext3_commit_write().
   59  */
   60 
   61 static ssize_t
   62 ext3_file_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
   63 {
   64         ssize_t ret;
   65         int err;
   66         struct inode *inode = file->f_dentry->d_inode;
   67 
   68         ret = generic_file_write(file, buf, count, ppos);
   69 
   70         /* Skip file flushing code if there was an error, or if nothing
   71            was written. */
   72         if (ret <= 0)
   73                 return ret;
   74         
   75         /* If the inode is IS_SYNC, or is O_SYNC and we are doing
   76            data-journaling, then we need to make sure that we force the
   77            transaction to disk to keep all metadata uptodate
   78            synchronously. */
   79 
   80         if (file->f_flags & O_SYNC) {
   81                 /* If we are non-data-journaled, then the dirty data has
   82                    already been flushed to backing store by
   83                    generic_osync_inode, and the inode has been flushed
   84                    too if there have been any modifications other than
   85                    mere timestamp updates.
   86                    
   87                    Open question --- do we care about flushing
   88                    timestamps too if the inode is IS_SYNC? */
   89                 if (!ext3_should_journal_data(inode))
   90                         return ret;
   91 
   92                 goto force_commit;
   93         }
   94 
   95         /* So we know that there has been no forced data flush.  If the
   96            inode is marked IS_SYNC, we need to force one ourselves. */
   97         if (!IS_SYNC(inode))
   98                 return ret;
   99         
  100         /* Open question #2 --- should we force data to disk here too?
  101            If we don't, the only impact is that data=writeback
  102            filesystems won't flush data to disk automatically on
  103            IS_SYNC, only metadata (but historically, that is what ext2
  104            has done.) */
  105         
  106 force_commit:
  107         err = ext3_force_commit(inode->i_sb);
  108         if (err) 
  109                 return err;
  110         return ret;
  111 }
  112 
  113 struct file_operations ext3_file_operations = {
  114         llseek:         generic_file_llseek,    /* BKL held */
  115         read:           generic_file_read,      /* BKL not held.  Don't need */
  116         write:          ext3_file_write,        /* BKL not held.  Don't need */
  117         ioctl:          ext3_ioctl,             /* BKL held */
  118         mmap:           generic_file_mmap,
  119         open:           ext3_open_file,         /* BKL not held.  Don't need */
  120         release:        ext3_release_file,      /* BKL not held.  Don't need */
  121         fsync:          ext3_sync_file,         /* BKL held */
  122 };
  123 
  124 struct inode_operations ext3_file_inode_operations = {
  125         truncate:       ext3_truncate,          /* BKL held */
  126         setattr:        ext3_setattr,           /* BKL held */
  127 };
  128

Cache object: 41cfc85f81f21ba652231304a2ac52a5

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/fs/ext3/file.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/ext3/file.c