LCOV - code coverage report
Current view: top level - include/linux - fs.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 20 20 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef _LINUX_FS_H
       2             : #define _LINUX_FS_H
       3             : 
       4             : /*
       5             :  * This file has definitions for some important file table
       6             :  * structures etc.
       7             :  */
       8             : 
       9             : #include <linux/limits.h>
      10             : #include <linux/ioctl.h>
      11             : 
      12             : /*
      13             :  * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
      14             :  * the file limit at runtime and only root can increase the per-process
      15             :  * nr_file rlimit, so it's safe to set up a ridiculously high absolute
      16             :  * upper limit on files-per-process.
      17             :  *
      18             :  * Some programs (notably those using select()) may have to be 
      19             :  * recompiled to take full advantage of the new limits..  
      20             :  */
      21             : 
      22             : /* Fixed constants first: */
      23             : #undef NR_OPEN
      24             : #define INR_OPEN 1024           /* Initial setting for nfile rlimits */
      25             : 
      26             : #define BLOCK_SIZE_BITS 10
      27             : #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
      28             : 
      29             : #define SEEK_SET        0       /* seek relative to beginning of file */
      30             : #define SEEK_CUR        1       /* seek relative to current file position */
      31             : #define SEEK_END        2       /* seek relative to end of file */
      32             : #define SEEK_MAX        SEEK_END
      33             : 
      34             : /* And dynamically-tunable limits and defaults: */
      35             : struct files_stat_struct {
      36             :         int nr_files;           /* read only */
      37             :         int nr_free_files;      /* read only */
      38             :         int max_files;          /* tunable */
      39             : };
      40             : 
      41             : struct inodes_stat_t {
      42             :         int nr_inodes;
      43             :         int nr_unused;
      44             :         int dummy[5];           /* padding for sysctl ABI compatibility */
      45             : };
      46             : 
      47             : 
      48             : #define NR_FILE  8192   /* this can well be larger on a larger system */
      49             : 
      50             : #define MAY_EXEC 1
      51             : #define MAY_WRITE 2
      52             : #define MAY_READ 4
      53             : #define MAY_APPEND 8
      54             : #define MAY_ACCESS 16
      55             : #define MAY_OPEN 32
      56             : 
      57             : /*
      58             :  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
      59             :  * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
      60             :  */
      61             : 
      62             : /* file is open for reading */
      63             : #define FMODE_READ              ((__force fmode_t)1)
      64             : /* file is open for writing */
      65             : #define FMODE_WRITE             ((__force fmode_t)2)
      66             : /* file is seekable */
      67             : #define FMODE_LSEEK             ((__force fmode_t)4)
      68             : /* file can be accessed using pread */
      69             : #define FMODE_PREAD             ((__force fmode_t)8)
      70             : /* file can be accessed using pwrite */
      71             : #define FMODE_PWRITE            ((__force fmode_t)16)
      72             : /* File is opened for execution with sys_execve / sys_uselib */
      73             : #define FMODE_EXEC              ((__force fmode_t)32)
      74             : /* File is opened with O_NDELAY (only set for block devices) */
      75             : #define FMODE_NDELAY            ((__force fmode_t)64)
      76             : /* File is opened with O_EXCL (only set for block devices) */
      77             : #define FMODE_EXCL              ((__force fmode_t)128)
      78             : /* File is opened using open(.., 3, ..) and is writeable only for ioctls
      79             :    (specialy hack for floppy.c) */
      80             : #define FMODE_WRITE_IOCTL       ((__force fmode_t)256)
      81             : 
      82             : /*
      83             :  * Don't update ctime and mtime.
      84             :  *
      85             :  * Currently a special hack for the XFS open_by_handle ioctl, but we'll
      86             :  * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
      87             :  */
      88             : #define FMODE_NOCMTIME          ((__force fmode_t)2048)
      89             : 
      90             : /* Expect random access pattern */
      91             : #define FMODE_RANDOM            ((__force fmode_t)4096)
      92             : 
      93             : /*
      94             :  * The below are the various read and write types that we support. Some of
      95             :  * them include behavioral modifiers that send information down to the
      96             :  * block layer and IO scheduler. Terminology:
      97             :  *
      98             :  *      The block layer uses device plugging to defer IO a little bit, in
      99             :  *      the hope that we will see more IO very shortly. This increases
     100             :  *      coalescing of adjacent IO and thus reduces the number of IOs we
     101             :  *      have to send to the device. It also allows for better queuing,
     102             :  *      if the IO isn't mergeable. If the caller is going to be waiting
     103             :  *      for the IO, then he must ensure that the device is unplugged so
     104             :  *      that the IO is dispatched to the driver.
     105             :  *
     106             :  *      All IO is handled async in Linux. This is fine for background
     107             :  *      writes, but for reads or writes that someone waits for completion
     108             :  *      on, we want to notify the block layer and IO scheduler so that they
     109             :  *      know about it. That allows them to make better scheduling
     110             :  *      decisions. So when the below references 'sync' and 'async', it
     111             :  *      is referencing this priority hint.
     112             :  *
     113             :  * With that in mind, the available types are:
     114             :  *
     115             :  * READ                 A normal read operation. Device will be plugged.
     116             :  * READ_SYNC            A synchronous read. Device is not plugged, caller can
     117             :  *                      immediately wait on this read without caring about
     118             :  *                      unplugging.
     119             :  * READA                Used for read-ahead operations. Lower priority, and the
     120             :  *                       block layer could (in theory) choose to ignore this
     121             :  *                      request if it runs into resource problems.
     122             :  * WRITE                A normal async write. Device will be plugged.
     123             :  * SWRITE               Like WRITE, but a special case for ll_rw_block() that
     124             :  *                      tells it to lock the buffer first. Normally a buffer
     125             :  *                      must be locked before doing IO.
     126             :  * WRITE_SYNC_PLUG      Synchronous write. Identical to WRITE, but passes down
     127             :  *                      the hint that someone will be waiting on this IO
     128             :  *                      shortly. The device must still be unplugged explicitly,
     129             :  *                      WRITE_SYNC_PLUG does not do this as we could be
     130             :  *                      submitting more writes before we actually wait on any
     131             :  *                      of them.
     132             :  * WRITE_SYNC           Like WRITE_SYNC_PLUG, but also unplugs the device
     133             :  *                      immediately after submission. The write equivalent
     134             :  *                      of READ_SYNC.
     135             :  * WRITE_ODIRECT_PLUG   Special case write for O_DIRECT only.
     136             :  * SWRITE_SYNC
     137             :  * SWRITE_SYNC_PLUG     Like WRITE_SYNC/WRITE_SYNC_PLUG, but locks the buffer.
     138             :  *                      See SWRITE.
     139             :  * WRITE_BARRIER        Like WRITE, but tells the block layer that all
     140             :  *                      previously submitted writes must be safely on storage
     141             :  *                      before this one is started. Also guarantees that when
     142             :  *                      this write is complete, it itself is also safely on
     143             :  *                      storage. Prevents reordering of writes on both sides
     144             :  *                      of this IO.
     145             :  *
     146             :  */
     147             : #define RW_MASK         1
     148             : #define RWA_MASK        2
     149             : #define READ 0
     150             : #define WRITE 1
     151             : #define READA 2         /* read-ahead  - don't block if no resources */
     152             : #define SWRITE 3        /* for ll_rw_block() - wait for buffer lock */
     153             : #define READ_SYNC       (READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
     154             : #define READ_META       (READ | (1 << BIO_RW_META))
     155             : #define WRITE_SYNC_PLUG (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
     156             : #define WRITE_SYNC      (WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
     157             : #define WRITE_ODIRECT_PLUG      (WRITE | (1 << BIO_RW_SYNCIO))
     158             : #define WRITE_META      (WRITE | (1 << BIO_RW_META))
     159             : #define SWRITE_SYNC_PLUG        \
     160             :                         (SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
     161             : #define SWRITE_SYNC     (SWRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
     162             : #define WRITE_BARRIER   (WRITE | (1 << BIO_RW_BARRIER))
     163             : 
     164             : /*
     165             :  * These aren't really reads or writes, they pass down information about
     166             :  * parts of device that are now unused by the file system.
     167             :  */
     168             : #define DISCARD_NOBARRIER (WRITE | (1 << BIO_RW_DISCARD))
     169             : #define DISCARD_BARRIER (DISCARD_NOBARRIER | (1 << BIO_RW_BARRIER))
     170             : 
     171             : #define SEL_IN          1
     172             : #define SEL_OUT         2
     173             : #define SEL_EX          4
     174             : 
     175             : /* public flags for file_system_type */
     176             : #define FS_REQUIRES_DEV 1 
     177             : #define FS_BINARY_MOUNTDATA 2
     178             : #define FS_HAS_SUBTYPE 4
     179             : #define FS_REVAL_DOT    16384   /* Check the paths ".", ".." for staleness */
     180             : #define FS_RENAME_DOES_D_MOVE   32768   /* FS will handle d_move()
     181             :                                          * during rename() internally.
     182             :                                          */
     183             : 
     184             : /*
     185             :  * These are the fs-independent mount-flags: up to 32 flags are supported
     186             :  */
     187             : #define MS_RDONLY        1      /* Mount read-only */
     188             : #define MS_NOSUID        2      /* Ignore suid and sgid bits */
     189             : #define MS_NODEV         4      /* Disallow access to device special files */
     190             : #define MS_NOEXEC        8      /* Disallow program execution */
     191             : #define MS_SYNCHRONOUS  16      /* Writes are synced at once */
     192             : #define MS_REMOUNT      32      /* Alter flags of a mounted FS */
     193             : #define MS_MANDLOCK     64      /* Allow mandatory locks on an FS */
     194             : #define MS_DIRSYNC      128     /* Directory modifications are synchronous */
     195             : #define MS_NOATIME      1024    /* Do not update access times. */
     196             : #define MS_NODIRATIME   2048    /* Do not update directory access times */
     197             : #define MS_BIND         4096
     198             : #define MS_MOVE         8192
     199             : #define MS_REC          16384
     200             : #define MS_VERBOSE      32768   /* War is peace. Verbosity is silence.
     201             :                                    MS_VERBOSE is deprecated. */
     202             : #define MS_SILENT       32768
     203             : #define MS_POSIXACL     (1<<16)   /* VFS does not apply the umask */
     204             : #define MS_UNBINDABLE   (1<<17)   /* change to unbindable */
     205             : #define MS_PRIVATE      (1<<18)   /* change to private */
     206             : #define MS_SLAVE        (1<<19)   /* change to slave */
     207             : #define MS_SHARED       (1<<20)   /* change to shared */
     208             : #define MS_RELATIME     (1<<21)   /* Update atime relative to mtime/ctime. */
     209             : #define MS_KERNMOUNT    (1<<22) /* this is a kern_mount call */
     210             : #define MS_I_VERSION    (1<<23) /* Update inode I_version field */
     211             : #define MS_STRICTATIME  (1<<24) /* Always perform atime updates */
     212             : #define MS_ACTIVE       (1<<30)
     213             : #define MS_NOUSER       (1<<31)
     214             : 
     215             : /*
     216             :  * Superblock flags that can be altered by MS_REMOUNT
     217             :  */
     218             : #define MS_RMT_MASK     (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_I_VERSION)
     219             : 
     220             : /*
     221             :  * Old magic mount flag and mask
     222             :  */
     223             : #define MS_MGC_VAL 0xC0ED0000
     224             : #define MS_MGC_MSK 0xffff0000
     225             : 
     226             : /* Inode flags - they have nothing to superblock flags now */
     227             : 
     228             : #define S_SYNC          1       /* Writes are synced at once */
     229             : #define S_NOATIME       2       /* Do not update access times */
     230             : #define S_APPEND        4       /* Append-only file */
     231             : #define S_IMMUTABLE     8       /* Immutable file */
     232             : #define S_DEAD          16      /* removed, but still open directory */
     233             : #define S_NOQUOTA       32      /* Inode is not counted to quota */
     234             : #define S_DIRSYNC       64      /* Directory modifications are synchronous */
     235             : #define S_NOCMTIME      128     /* Do not update file c/mtime */
     236             : #define S_SWAPFILE      256     /* Do not truncate: swapon got its bmaps */
     237             : #define S_PRIVATE       512     /* Inode is fs-internal */
     238             : 
     239             : /*
     240             :  * Note that nosuid etc flags are inode-specific: setting some file-system
     241             :  * flags just means all the inodes inherit those flags by default. It might be
     242             :  * possible to override it selectively if you really wanted to with some
     243             :  * ioctl() that is not currently implemented.
     244             :  *
     245             :  * Exception: MS_RDONLY is always applied to the entire file system.
     246             :  *
     247             :  * Unfortunately, it is possible to change a filesystems flags with it mounted
     248             :  * with files in use.  This means that all of the inodes will not have their
     249             :  * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
     250             :  * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
     251             :  */
     252             : #define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
     253             : 
     254             : #define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
     255             : #define IS_SYNC(inode)          (__IS_FLG(inode, MS_SYNCHRONOUS) || \
     256             :                                         ((inode)->i_flags & S_SYNC))
     257             : #define IS_DIRSYNC(inode)       (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
     258             :                                         ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
     259             : #define IS_MANDLOCK(inode)      __IS_FLG(inode, MS_MANDLOCK)
     260             : #define IS_NOATIME(inode)   __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
     261             : #define IS_I_VERSION(inode)   __IS_FLG(inode, MS_I_VERSION)
     262             : 
     263             : #define IS_NOQUOTA(inode)       ((inode)->i_flags & S_NOQUOTA)
     264             : #define IS_APPEND(inode)        ((inode)->i_flags & S_APPEND)
     265             : #define IS_IMMUTABLE(inode)     ((inode)->i_flags & S_IMMUTABLE)
     266             : #define IS_POSIXACL(inode)      __IS_FLG(inode, MS_POSIXACL)
     267             : 
     268             : #define IS_DEADDIR(inode)       ((inode)->i_flags & S_DEAD)
     269             : #define IS_NOCMTIME(inode)      ((inode)->i_flags & S_NOCMTIME)
     270             : #define IS_SWAPFILE(inode)      ((inode)->i_flags & S_SWAPFILE)
     271             : #define IS_PRIVATE(inode)       ((inode)->i_flags & S_PRIVATE)
     272             : 
     273             : /* the read-only stuff doesn't really belong here, but any other place is
     274             :    probably as bad and I don't want to create yet another include file. */
     275             : 
     276             : #define BLKROSET   _IO(0x12,93) /* set device read-only (0 = read-write) */
     277             : #define BLKROGET   _IO(0x12,94) /* get read-only status (0 = read_write) */
     278             : #define BLKRRPART  _IO(0x12,95) /* re-read partition table */
     279             : #define BLKGETSIZE _IO(0x12,96) /* return device size /512 (long *arg) */
     280             : #define BLKFLSBUF  _IO(0x12,97) /* flush buffer cache */
     281             : #define BLKRASET   _IO(0x12,98) /* set read ahead for block device */
     282             : #define BLKRAGET   _IO(0x12,99) /* get current read ahead setting */
     283             : #define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
     284             : #define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
     285             : #define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
     286             : #define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
     287             : #define BLKSSZGET  _IO(0x12,104)/* get block device sector size */
     288             : #if 0
     289             : #define BLKPG      _IO(0x12,105)/* See blkpg.h */
     290             : 
     291             : /* Some people are morons.  Do not use sizeof! */
     292             : 
     293             : #define BLKELVGET  _IOR(0x12,106,size_t)/* elevator get */
     294             : #define BLKELVSET  _IOW(0x12,107,size_t)/* elevator set */
     295             : /* This was here just to show that the number is taken -
     296             :    probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
     297             : #endif
     298             : /* A jump here: 108-111 have been used for various private purposes. */
     299             : #define BLKBSZGET  _IOR(0x12,112,size_t)
     300             : #define BLKBSZSET  _IOW(0x12,113,size_t)
     301             : #define BLKGETSIZE64 _IOR(0x12,114,size_t)      /* return device size in bytes (u64 *arg) */
     302             : #define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
     303             : #define BLKTRACESTART _IO(0x12,116)
     304             : #define BLKTRACESTOP _IO(0x12,117)
     305             : #define BLKTRACETEARDOWN _IO(0x12,118)
     306             : #define BLKDISCARD _IO(0x12,119)
     307             : #define BLKIOMIN _IO(0x12,120)
     308             : #define BLKIOOPT _IO(0x12,121)
     309             : #define BLKALIGNOFF _IO(0x12,122)
     310             : #define BLKPBSZGET _IO(0x12,123)
     311             : #define BLKDISCARDZEROES _IO(0x12,124)
     312             : 
     313             : #define BMAP_IOCTL 1            /* obsolete - kept for compatibility */
     314             : #define FIBMAP     _IO(0x00,1)  /* bmap access */
     315             : #define FIGETBSZ   _IO(0x00,2)  /* get the block size used for bmap */
     316             : #define FIFREEZE        _IOWR('X', 119, int)    /* Freeze */
     317             : #define FITHAW          _IOWR('X', 120, int)    /* Thaw */
     318             : 
     319             : #define FS_IOC_GETFLAGS                 _IOR('f', 1, long)
     320             : #define FS_IOC_SETFLAGS                 _IOW('f', 2, long)
     321             : #define FS_IOC_GETVERSION               _IOR('v', 1, long)
     322             : #define FS_IOC_SETVERSION               _IOW('v', 2, long)
     323             : #define FS_IOC_FIEMAP                   _IOWR('f', 11, struct fiemap)
     324             : #define FS_IOC32_GETFLAGS               _IOR('f', 1, int)
     325             : #define FS_IOC32_SETFLAGS               _IOW('f', 2, int)
     326             : #define FS_IOC32_GETVERSION             _IOR('v', 1, int)
     327             : #define FS_IOC32_SETVERSION             _IOW('v', 2, int)
     328             : 
     329             : /*
     330             :  * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
     331             :  */
     332             : #define FS_SECRM_FL                     0x00000001 /* Secure deletion */
     333             : #define FS_UNRM_FL                      0x00000002 /* Undelete */
     334             : #define FS_COMPR_FL                     0x00000004 /* Compress file */
     335             : #define FS_SYNC_FL                      0x00000008 /* Synchronous updates */
     336             : #define FS_IMMUTABLE_FL                 0x00000010 /* Immutable file */
     337             : #define FS_APPEND_FL                    0x00000020 /* writes to file may only append */
     338             : #define FS_NODUMP_FL                    0x00000040 /* do not dump file */
     339             : #define FS_NOATIME_FL                   0x00000080 /* do not update atime */
     340             : /* Reserved for compression usage... */
     341             : #define FS_DIRTY_FL                     0x00000100
     342             : #define FS_COMPRBLK_FL                  0x00000200 /* One or more compressed clusters */
     343             : #define FS_NOCOMP_FL                    0x00000400 /* Don't compress */
     344             : #define FS_ECOMPR_FL                    0x00000800 /* Compression error */
     345             : /* End compression flags --- maybe not all used */
     346             : #define FS_BTREE_FL                     0x00001000 /* btree format dir */
     347             : #define FS_INDEX_FL                     0x00001000 /* hash-indexed directory */
     348             : #define FS_IMAGIC_FL                    0x00002000 /* AFS directory */
     349             : #define FS_JOURNAL_DATA_FL              0x00004000 /* Reserved for ext3 */
     350             : #define FS_NOTAIL_FL                    0x00008000 /* file tail should not be merged */
     351             : #define FS_DIRSYNC_FL                   0x00010000 /* dirsync behaviour (directories only) */
     352             : #define FS_TOPDIR_FL                    0x00020000 /* Top of directory hierarchies*/
     353             : #define FS_EXTENT_FL                    0x00080000 /* Extents */
     354             : #define FS_DIRECTIO_FL                  0x00100000 /* Use direct i/o */
     355             : #define FS_RESERVED_FL                  0x80000000 /* reserved for ext2 lib */
     356             : 
     357             : #define FS_FL_USER_VISIBLE              0x0003DFFF /* User visible flags */
     358             : #define FS_FL_USER_MODIFIABLE           0x000380FF /* User modifiable flags */
     359             : 
     360             : 
     361             : #define SYNC_FILE_RANGE_WAIT_BEFORE     1
     362             : #define SYNC_FILE_RANGE_WRITE           2
     363             : #define SYNC_FILE_RANGE_WAIT_AFTER      4
     364             : 
     365             : #ifdef __KERNEL__
     366             : 
     367             : #include <linux/linkage.h>
     368             : #include <linux/wait.h>
     369             : #include <linux/types.h>
     370             : #include <linux/kdev_t.h>
     371             : #include <linux/dcache.h>
     372             : #include <linux/path.h>
     373             : #include <linux/stat.h>
     374             : #include <linux/cache.h>
     375             : #include <linux/kobject.h>
     376             : #include <linux/list.h>
     377             : #include <linux/radix-tree.h>
     378             : #include <linux/prio_tree.h>
     379             : #include <linux/init.h>
     380             : #include <linux/pid.h>
     381             : #include <linux/mutex.h>
     382             : #include <linux/capability.h>
     383             : #include <linux/semaphore.h>
     384             : #include <linux/fiemap.h>
     385             : 
     386             : #include <asm/atomic.h>
     387             : #include <asm/byteorder.h>
     388             : 
     389             : struct export_operations;
     390             : struct hd_geometry;
     391             : struct iovec;
     392             : struct nameidata;
     393             : struct kiocb;
     394             : struct pipe_inode_info;
     395             : struct poll_table_struct;
     396             : struct kstatfs;
     397             : struct vm_area_struct;
     398             : struct vfsmount;
     399             : struct cred;
     400             : 
     401             : extern void __init inode_init(void);
     402             : extern void __init inode_init_early(void);
     403             : extern void __init files_init(unsigned long);
     404             : 
     405             : extern struct files_stat_struct files_stat;
     406             : extern int get_max_files(void);
     407             : extern int sysctl_nr_open;
     408             : extern struct inodes_stat_t inodes_stat;
     409             : extern int leases_enable, lease_break_time;
     410             : #ifdef CONFIG_DNOTIFY
     411             : extern int dir_notify_enable;
     412             : #endif
     413             : 
     414             : struct buffer_head;
     415             : typedef int (get_block_t)(struct inode *inode, sector_t iblock,
     416             :                         struct buffer_head *bh_result, int create);
     417             : typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
     418           1 :                         ssize_t bytes, void *private);
     419             : 
     420             : /*
     421             :  * Attribute flags.  These should be or-ed together to figure out what
     422             :  * has been changed!
     423             :  */
     424             : #define ATTR_MODE       (1 << 0)
     425             : #define ATTR_UID        (1 << 1)
     426             : #define ATTR_GID        (1 << 2)
     427             : #define ATTR_SIZE       (1 << 3)
     428             : #define ATTR_ATIME      (1 << 4)
     429             : #define ATTR_MTIME      (1 << 5)
     430             : #define ATTR_CTIME      (1 << 6)
     431             : #define ATTR_ATIME_SET  (1 << 7)
     432             : #define ATTR_MTIME_SET  (1 << 8)
     433             : #define ATTR_FORCE      (1 << 9) /* Not a change, but a change it */
     434             : #define ATTR_ATTR_FLAG  (1 << 10)
     435             : #define ATTR_KILL_SUID  (1 << 11)
     436             : #define ATTR_KILL_SGID  (1 << 12)
     437             : #define ATTR_FILE       (1 << 13)
     438             : #define ATTR_KILL_PRIV  (1 << 14)
     439             : #define ATTR_OPEN       (1 << 15) /* Truncating from open(O_TRUNC) */
     440             : #define ATTR_TIMES_SET  (1 << 16)
     441             : 
     442             : /*
     443             :  * This is the Inode Attributes structure, used for notify_change().  It
     444             :  * uses the above definitions as flags, to know which values have changed.
     445             :  * Also, in this manner, a Filesystem can look at only the values it cares
     446             :  * about.  Basically, these are the attributes that the VFS layer can
     447             :  * request to change from the FS layer.
     448             :  *
     449             :  * Derek Atkins <warlord@MIT.EDU> 94-10-20
     450             :  */
     451             : struct iattr {
     452             :         unsigned int    ia_valid;
     453             :         umode_t         ia_mode;
     454             :         uid_t           ia_uid;
     455             :         gid_t           ia_gid;
     456             :         loff_t          ia_size;
     457             :         struct timespec ia_atime;
     458             :         struct timespec ia_mtime;
     459             :         struct timespec ia_ctime;
     460             : 
     461             :         /*
     462             :          * Not an attribute, but an auxilary info for filesystems wanting to
     463             :          * implement an ftruncate() like method.  NOTE: filesystem should
     464             :          * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
     465             :          */
     466             :         struct file     *ia_file;
     467             : };
     468             : 
     469             : /*
     470             :  * Includes for diskquotas.
     471             :  */
     472             : #include <linux/quota.h>
     473             : 
     474             : /** 
     475             :  * enum positive_aop_returns - aop return codes with specific semantics
     476             :  *
     477           1 :  * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
     478             :  *                          completed, that the page is still locked, and
     479             :  *                          should be considered active.  The VM uses this hint
     480             :  *                          to return the page to the active list -- it won't
     481             :  *                          be a candidate for writeback again in the near
     482             :  *                          future.  Other callers must be careful to unlock
     483             :  *                          the page if they get this return.  Returned by
     484             :  *                          writepage(); 
     485             :  *
     486             :  * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
     487             :  *                      unlocked it and the page might have been truncated.
     488             :  *                      The caller should back up to acquiring a new page and
     489             :  *                      trying again.  The aop will be taking reasonable
     490             :  *                      precautions not to livelock.  If the caller held a page
     491             :  *                      reference, it should drop it before retrying.  Returned
     492             :  *                      by readpage().
     493             :  *
     494             :  * address_space_operation functions return these large constants to indicate
     495             :  * special semantics to the caller.  These are much larger than the bytes in a
     496             :  * page to allow for functions that return the number of bytes operated on in a
     497             :  * given page.
     498             :  */
     499             : 
     500             : enum positive_aop_returns {
     501             :         AOP_WRITEPAGE_ACTIVATE  = 0x80000,
     502             :         AOP_TRUNCATED_PAGE      = 0x80001,
     503             : };
     504             : 
     505             : #define AOP_FLAG_UNINTERRUPTIBLE        0x0001 /* will not do a short write */
     506             : #define AOP_FLAG_CONT_EXPAND            0x0002 /* called from cont_expand */
     507             : #define AOP_FLAG_NOFS                   0x0004 /* used by filesystem to direct
     508             :                                                 * helper code (eg buffer layer)
     509             :                                                 * to clear GFP_FS from alloc */
     510             : 
     511             : /*
     512             :  * oh the beauties of C type declarations.
     513             :  */
     514             : struct page;
     515             : struct address_space;
     516             : struct writeback_control;
     517             : 
     518             : struct iov_iter {
     519             :         const struct iovec *iov;
     520             :         unsigned long nr_segs;
     521             :         size_t iov_offset;
     522             :         size_t count;
     523             : };
     524             : 
     525             : size_t iov_iter_copy_from_user_atomic(struct page *page,
     526             :                 struct iov_iter *i, unsigned long offset, size_t bytes);
     527             : size_t iov_iter_copy_from_user(struct page *page,
     528             :                 struct iov_iter *i, unsigned long offset, size_t bytes);
     529             : void iov_iter_advance(struct iov_iter *i, size_t bytes);
     530             : int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
     531             : size_t iov_iter_single_seg_count(struct iov_iter *i);
     532             : 
     533             : static inline void iov_iter_init(struct iov_iter *i,
     534             :                         const struct iovec *iov, unsigned long nr_segs,
     535             :                         size_t count, size_t written)
     536             : {
     537             :         i->iov = iov;
     538             :         i->nr_segs = nr_segs;
     539             :         i->iov_offset = 0;
     540             :         i->count = count + written;
     541             : 
     542             :         iov_iter_advance(i, written);
     543             : }
     544             : 
     545             : static inline size_t iov_iter_count(struct iov_iter *i)
     546             : {
     547             :         return i->count;
     548             : }
     549             : 
     550             : /*
     551             :  * "descriptor" for what we're up to with a read.
     552             :  * This allows us to use the same read code yet
     553             :  * have multiple different users of the data that
     554             :  * we read from a file.
     555             :  *
     556             :  * The simplest case just copies the data to user
     557             :  * mode.
     558             :  */
     559             : typedef struct {
     560             :         size_t written;
     561             :         size_t count;
     562             :         union {
     563             :                 char __user *buf;
     564             :                 void *data;
     565             :         } arg;
     566             :         int error;
     567           3 : } read_descriptor_t;
     568             : 
     569             : typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
     570           1 :                 unsigned long, unsigned long);
     571             : 
     572             : struct address_space_operations {
     573             :         int (*writepage)(struct page *page, struct writeback_control *wbc);
     574             :         int (*readpage)(struct file *, struct page *);
     575             :         void (*sync_page)(struct page *);
     576             : 
     577             :         /* Write back some dirty pages from this mapping. */
     578             :         int (*writepages)(struct address_space *, struct writeback_control *);
     579             : 
     580             :         /* Set a page dirty.  Return true if this dirtied it */
     581             :         int (*set_page_dirty)(struct page *page);
     582             : 
     583             :         int (*readpages)(struct file *filp, struct address_space *mapping,
     584             :                         struct list_head *pages, unsigned nr_pages);
     585             : 
     586             :         int (*write_begin)(struct file *, struct address_space *mapping,
     587             :                                 loff_t pos, unsigned len, unsigned flags,
     588             :                                 struct page **pagep, void **fsdata);
     589             :         int (*write_end)(struct file *, struct address_space *mapping,
     590             :                                 loff_t pos, unsigned len, unsigned copied,
     591             :                                 struct page *page, void *fsdata);
     592             : 
     593             :         /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
     594             :         sector_t (*bmap)(struct address_space *, sector_t);
     595             :         void (*invalidatepage) (struct page *, unsigned long);
     596             :         int (*releasepage) (struct page *, gfp_t);
     597             :         ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
     598             :                         loff_t offset, unsigned long nr_segs);
     599             :         int (*get_xip_mem)(struct address_space *, pgoff_t, int,
     600             :                                                 void **, unsigned long *);
     601             :         /* migrate the contents of a page to the specified target */
     602             :         int (*migratepage) (struct address_space *,
     603             :                         struct page *, struct page *);
     604             :         int (*launder_page) (struct page *);
     605             :         int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
     606             :                                         unsigned long);
     607             :         int (*error_remove_page)(struct address_space *, struct page *);
     608             : };
     609             : 
     610             : /*
     611             :  * pagecache_write_begin/pagecache_write_end must be used by general code
     612             :  * to write into the pagecache.
     613             :  */
     614             : int pagecache_write_begin(struct file *, struct address_space *mapping,
     615             :                                 loff_t pos, unsigned len, unsigned flags,
     616             :                                 struct page **pagep, void **fsdata);
     617             : 
     618             : int pagecache_write_end(struct file *, struct address_space *mapping,
     619           1 :                                 loff_t pos, unsigned len, unsigned copied,
     620             :                                 struct page *page, void *fsdata);
     621             : 
     622             : struct backing_dev_info;
     623             : struct address_space {
     624             :         struct inode            *host;          /* owner: inode, block_device */
     625             :         struct radix_tree_root  page_tree;      /* radix tree of all pages */
     626             :         spinlock_t              tree_lock;      /* and lock protecting it */
     627             :         unsigned int            i_mmap_writable;/* count VM_SHARED mappings */
     628             :         struct prio_tree_root   i_mmap;         /* tree of private and shared mappings */
     629             :         struct list_head        i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
     630             :         spinlock_t              i_mmap_lock;    /* protect tree, count, list */
     631             :         unsigned int            truncate_count; /* Cover race condition with truncate */
     632             :         unsigned long           nrpages;        /* number of total pages */
     633             :         pgoff_t                 writeback_index;/* writeback starts here */
     634             :         const struct address_space_operations *a_ops;   /* methods */
     635             :         unsigned long           flags;          /* error bits/gfp mask */
     636             :         struct backing_dev_info *backing_dev_info; /* device readahead, etc */
     637             :         spinlock_t              private_lock;   /* for use by the address_space */
     638             :         struct list_head        private_list;   /* ditto */
     639             :         struct address_space    *assoc_mapping; /* ditto */
     640             :         struct mutex            unmap_mutex;    /* to protect unmapping */
     641             : } __attribute__((aligned(sizeof(long))));
     642           3 :         /*
     643             :          * On most architectures that alignment is already the case; but
     644             :          * must be enforced here for CRIS, to let the least signficant bit
     645             :          * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
     646             :          */
     647             : 
     648             : struct block_device {
     649             :         dev_t                   bd_dev;  /* not a kdev_t - it's a search key */
     650             :         struct inode *          bd_inode;       /* will die */
     651             :         struct super_block *    bd_super;
     652             :         int                     bd_openers;
     653             :         struct mutex            bd_mutex;       /* open/close mutex */
     654             :         struct list_head        bd_inodes;
     655             :         void *                  bd_holder;
     656             :         int                     bd_holders;
     657             : #ifdef CONFIG_SYSFS
     658             :         struct list_head        bd_holder_list;
     659             : #endif
     660             :         struct block_device *   bd_contains;
     661             :         unsigned                bd_block_size;
     662             :         struct hd_struct *      bd_part;
     663             :         /* number of times partitions within this device have been opened. */
     664             :         unsigned                bd_part_count;
     665             :         int                     bd_invalidated;
     666             :         struct gendisk *        bd_disk;
     667             :         struct list_head        bd_list;
     668             :         /*
     669             :          * Private data.  You must have bd_claim'ed the block_device
     670             :          * to use this.  NOTE:  bd_claim allows an owner to claim
     671             :          * the same device multiple times, the owner must take special
     672             :          * care to not mess up bd_private for that case.
     673             :          */
     674             :         unsigned long           bd_private;
     675             : 
     676             :         /* The counter of freeze processes */
     677             :         int                     bd_fsfreeze_count;
     678             :         /* Mutex for freeze */
     679             :         struct mutex            bd_fsfreeze_mutex;
     680             : };
     681             : 
     682             : /*
     683             :  * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
     684             :  * radix trees
     685             :  */
     686             : #define PAGECACHE_TAG_DIRTY     0
     687             : #define PAGECACHE_TAG_WRITEBACK 1
     688             : 
     689             : int mapping_tagged(struct address_space *mapping, int tag);
     690             : 
     691             : /*
     692             :  * Might pages of this file be mapped into userspace?
     693             :  */
     694             : static inline int mapping_mapped(struct address_space *mapping)
     695             : {
     696             :         return  !prio_tree_empty(&mapping->i_mmap) ||
     697             :                 !list_empty(&mapping->i_mmap_nonlinear);
     698             : }
     699             : 
     700             : /*
     701             :  * Might pages of this file have been modified in userspace?
     702             :  * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
     703             :  * marks vma as VM_SHARED if it is shared, and the file was opened for
     704             :  * writing i.e. vma may be mprotected writable even if now readonly.
     705             :  */
     706             : static inline int mapping_writably_mapped(struct address_space *mapping)
     707             : {
     708             :         return mapping->i_mmap_writable != 0;
     709             : }
     710             : 
     711           6 : /*
     712             :  * Use sequence counter to get consistent i_size on 32-bit processors.
     713             :  */
     714             : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
     715             : #include <linux/seqlock.h>
     716             : #define __NEED_I_SIZE_ORDERED
     717             : #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
     718             : #else
     719             : #define i_size_ordered_init(inode) do { } while (0)
     720             : #endif
     721             : 
     722             : struct posix_acl;
     723             : #define ACL_NOT_CACHED ((void *)(-1))
     724             : 
     725             : struct inode {
     726             :         struct hlist_node       i_hash;
     727             :         struct list_head        i_list;         /* backing dev IO list */
     728             :         struct list_head        i_sb_list;
     729             :         struct list_head        i_dentry;
     730             :         unsigned long           i_ino;
     731             :         atomic_t                i_count;
     732             :         unsigned int            i_nlink;
     733             :         uid_t                   i_uid;
     734             :         gid_t                   i_gid;
     735             :         dev_t                   i_rdev;
     736             :         unsigned int            i_blkbits;
     737             :         u64                     i_version;
     738             :         loff_t                  i_size;
     739             : #ifdef __NEED_I_SIZE_ORDERED
     740             :         seqcount_t              i_size_seqcount;
     741             : #endif
     742             :         struct timespec         i_atime;
     743             :         struct timespec         i_mtime;
     744             :         struct timespec         i_ctime;
     745             :         blkcnt_t                i_blocks;
     746             :         unsigned short          i_bytes;
     747             :         umode_t                 i_mode;
     748             :         spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
     749             :         struct mutex            i_mutex;
     750             :         struct rw_semaphore     i_alloc_sem;
     751             :         const struct inode_operations   *i_op;
     752             :         const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
     753             :         struct super_block      *i_sb;
     754             :         struct file_lock        *i_flock;
     755             :         struct address_space    *i_mapping;
     756             :         struct address_space    i_data;
     757             : #ifdef CONFIG_QUOTA
     758             :         struct dquot            *i_dquot[MAXQUOTAS];
     759             : #endif
     760             :         struct list_head        i_devices;
     761             :         union {
     762             :                 struct pipe_inode_info  *i_pipe;
     763             :                 struct block_device     *i_bdev;
     764             :                 struct cdev             *i_cdev;
     765             :         };
     766             : 
     767             :         __u32                   i_generation;
     768             : 
     769             : #ifdef CONFIG_FSNOTIFY
     770             :         __u32                   i_fsnotify_mask; /* all events this inode cares about */
     771             :         struct hlist_head       i_fsnotify_mark_entries; /* fsnotify mark entries */
     772             : #endif
     773             : 
     774             : #ifdef CONFIG_INOTIFY
     775             :         struct list_head        inotify_watches; /* watches on this inode */
     776             :         struct mutex            inotify_mutex;  /* protects the watches list */
     777             : #endif
     778             : 
     779             :         unsigned long           i_state;
     780             :         unsigned long           dirtied_when;   /* jiffies of first dirtying */
     781             : 
     782             :         unsigned int            i_flags;
     783             : 
     784             :         atomic_t                i_writecount;
     785             : #ifdef CONFIG_SECURITY
     786             :         void                    *i_security;
     787             : #endif
     788             : #ifdef CONFIG_FS_POSIX_ACL
     789             :         struct posix_acl        *i_acl;
     790             :         struct posix_acl        *i_default_acl;
     791             : #endif
     792             :         void                    *i_private; /* fs or device private pointer */
     793             : };
     794             : 
     795             : /*
     796             :  * inode->i_mutex nesting subclasses for the lock validator:
     797             :  *
     798             :  * 0: the object of the current VFS operation
     799             :  * 1: parent
     800             :  * 2: child/target
     801             :  * 3: quota file
     802             :  *
     803             :  * The locking order between these classes is
     804             :  * parent -> child -> normal -> xattr -> quota
     805             :  */
     806             : enum inode_i_mutex_lock_class
     807             : {
     808             :         I_MUTEX_NORMAL,
     809             :         I_MUTEX_PARENT,
     810             :         I_MUTEX_CHILD,
     811             :         I_MUTEX_XATTR,
     812             :         I_MUTEX_QUOTA
     813             : };
     814             : 
     815             : /*
     816             :  * NOTE: in a 32bit arch with a preemptable kernel and
     817             :  * an UP compile the i_size_read/write must be atomic
     818             :  * with respect to the local cpu (unlike with preempt disabled),
     819             :  * but they don't need to be atomic with respect to other cpus like in
     820             :  * true SMP (so they need either to either locally disable irq around
     821             :  * the read or for example on x86 they can be still implemented as a
     822             :  * cmpxchg8b without the need of the lock prefix). For SMP compiles
     823             :  * and 64bit archs it makes no difference if preempt is enabled or not.
     824             :  */
     825             : static inline loff_t i_size_read(const struct inode *inode)
     826             : {
     827             : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
     828             :         loff_t i_size;
     829             :         unsigned int seq;
     830             : 
     831             :         do {
     832             :                 seq = read_seqcount_begin(&inode->i_size_seqcount);
     833             :                 i_size = inode->i_size;
     834             :         } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
     835             :         return i_size;
     836             : #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
     837             :         loff_t i_size;
     838             : 
     839             :         preempt_disable();
     840             :         i_size = inode->i_size;
     841             :         preempt_enable();
     842             :         return i_size;
     843             : #else
     844             :         return inode->i_size;
     845             : #endif
     846             : }
     847             : 
     848             : /*
     849             :  * NOTE: unlike i_size_read(), i_size_write() does need locking around it
     850             :  * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
     851             :  * can be lost, resulting in subsequent i_size_read() calls spinning forever.
     852             :  */
     853             : static inline void i_size_write(struct inode *inode, loff_t i_size)
     854             : {
     855             : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
     856             :         write_seqcount_begin(&inode->i_size_seqcount);
     857             :         inode->i_size = i_size;
     858             :         write_seqcount_end(&inode->i_size_seqcount);
     859             : #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
     860             :         preempt_disable();
     861             :         inode->i_size = i_size;
     862             :         preempt_enable();
     863             : #else
     864             :         inode->i_size = i_size;
     865             : #endif
     866             : }
     867             : 
     868             : static inline unsigned iminor(const struct inode *inode)
     869             : {
     870             :         return MINOR(inode->i_rdev);
     871             : }
     872             : 
     873             : static inline unsigned imajor(const struct inode *inode)
     874             : {
     875             :         return MAJOR(inode->i_rdev);
     876             : }
     877             : 
     878             : extern struct block_device *I_BDEV(struct inode *inode);
     879           1 : 
     880             : struct fown_struct {
     881             :         rwlock_t lock;          /* protects pid, uid, euid fields */
     882             :         struct pid *pid;        /* pid or -pgrp where SIGIO should be sent */
     883             :         enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
     884             :         uid_t uid, euid;        /* uid/euid of process setting the owner */
     885             :         int signum;             /* posix.1b rt signal to be delivered on IO */
     886             : };
     887           1 : 
     888             : /*
     889             :  * Track a single file's readahead state
     890             :  */
     891             : struct file_ra_state {
     892             :         pgoff_t start;                  /* where readahead started */
     893             :         unsigned int size;              /* # of readahead pages */
     894             :         unsigned int async_size;        /* do asynchronous readahead when
     895             :                                            there are only # of pages ahead */
     896             : 
     897             :         unsigned int ra_pages;          /* Maximum readahead window */
     898             :         unsigned int mmap_miss;         /* Cache miss stat for mmap accesses */
     899             :         loff_t prev_pos;                /* Cache last read() position */
     900             : };
     901             : 
     902             : /*
     903             :  * Check if @index falls in the readahead windows.
     904             :  */
     905             : static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
     906             : {
     907             :         return (index >= ra->start &&
     908             :                 index <  ra->start + ra->size);
     909             : }
     910           2 : 
     911             : #define FILE_MNT_WRITE_TAKEN    1
     912             : #define FILE_MNT_WRITE_RELEASED 2
     913             : 
     914             : struct file {
     915             :         /*
     916             :          * fu_list becomes invalid after file_free is called and queued via
     917             :          * fu_rcuhead for RCU freeing
     918             :          */
     919             :         union {
     920             :                 struct list_head        fu_list;
     921             :                 struct rcu_head         fu_rcuhead;
     922             :         } f_u;
     923             :         struct path             f_path;
     924             : #define f_dentry        f_path.dentry
     925             : #define f_vfsmnt        f_path.mnt
     926             :         const struct file_operations    *f_op;
     927             :         spinlock_t              f_lock;  /* f_ep_links, f_flags, no IRQ */
     928             :         atomic_long_t           f_count;
     929             :         unsigned int            f_flags;
     930             :         fmode_t                 f_mode;
     931             :         loff_t                  f_pos;
     932             :         struct fown_struct      f_owner;
     933             :         const struct cred       *f_cred;
     934             :         struct file_ra_state    f_ra;
     935             : 
     936             :         u64                     f_version;
     937             : #ifdef CONFIG_SECURITY
     938             :         void                    *f_security;
     939             : #endif
     940             :         /* needed for tty driver, and maybe others */
     941             :         void                    *private_data;
     942             : 
     943             : #ifdef CONFIG_EPOLL
     944             :         /* Used by fs/eventpoll.c to link all the hooks to this file */
     945             :         struct list_head        f_ep_links;
     946             : #endif /* #ifdef CONFIG_EPOLL */
     947             :         struct address_space    *f_mapping;
     948             : #ifdef CONFIG_DEBUG_WRITECOUNT
     949             :         unsigned long f_mnt_write_state;
     950             : #endif
     951             : };
     952             : extern spinlock_t files_lock;
     953             : #define file_list_lock() spin_lock(&files_lock);
     954             : #define file_list_unlock() spin_unlock(&files_lock);
     955             : 
     956             : #define get_file(x)     atomic_long_inc(&(x)->f_count)
     957             : #define file_count(x)   atomic_long_read(&(x)->f_count)
     958             : 
     959             : #ifdef CONFIG_DEBUG_WRITECOUNT
     960             : static inline void file_take_write(struct file *f)
     961             : {
     962             :         WARN_ON(f->f_mnt_write_state != 0);
     963             :         f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN;
     964             : }
     965             : static inline void file_release_write(struct file *f)
     966             : {
     967             :         f->f_mnt_write_state |= FILE_MNT_WRITE_RELEASED;
     968             : }
     969             : static inline void file_reset_write(struct file *f)
     970             : {
     971             :         f->f_mnt_write_state = 0;
     972             : }
     973             : static inline void file_check_state(struct file *f)
     974             : {
     975             :         /*
     976             :          * At this point, either both or neither of these bits
     977             :          * should be set.
     978             :          */
     979             :         WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN);
     980             :         WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_RELEASED);
     981             : }
     982             : static inline int file_check_writeable(struct file *f)
     983             : {
     984             :         if (f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN)
     985             :                 return 0;
     986             :         printk(KERN_WARNING "writeable file with no "
     987             :                             "mnt_want_write()\n");
     988             :         WARN_ON(1);
     989             :         return -EINVAL;
     990             : }
     991             : #else /* !CONFIG_DEBUG_WRITECOUNT */
     992             : static inline void file_take_write(struct file *filp) {}
     993             : static inline void file_release_write(struct file *filp) {}
     994             : static inline void file_reset_write(struct file *filp) {}
     995             : static inline void file_check_state(struct file *filp) {}
     996             : static inline int file_check_writeable(struct file *filp)
     997             : {
     998             :         return 0;
     999             : }
    1000             : #endif /* CONFIG_DEBUG_WRITECOUNT */
    1001             : 
    1002             : #define MAX_NON_LFS     ((1UL<<31) - 1)
    1003             : 
    1004             : /* Page cache limit. The filesystems should put that into their s_maxbytes 
    1005             :    limits, otherwise bad things can happen in VM. */ 
    1006             : #if BITS_PER_LONG==32
    1007             : #define MAX_LFS_FILESIZE        (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1) 
    1008             : #elif BITS_PER_LONG==64
    1009             : #define MAX_LFS_FILESIZE        0x7fffffffffffffffUL
    1010             : #endif
    1011             : 
    1012             : #define FL_POSIX        1
    1013             : #define FL_FLOCK        2
    1014             : #define FL_ACCESS       8       /* not trying to lock, just looking */
    1015             : #define FL_EXISTS       16      /* when unlocking, test for existence */
    1016             : #define FL_LEASE        32      /* lease held on this file */
    1017             : #define FL_CLOSE        64      /* unlock on close */
    1018             : #define FL_SLEEP        128     /* A blocking lock */
    1019             : 
    1020             : /*
    1021             :  * Special return value from posix_lock_file() and vfs_lock_file() for
    1022             :  * asynchronous locking.
    1023             :  */
    1024             : #define FILE_LOCK_DEFERRED 1
    1025             : 
    1026             : /*
    1027             :  * The POSIX file lock owner is determined by
    1028             :  * the "struct files_struct" in the thread group
    1029             :  * (or NULL for no owner - BSD locks).
    1030             :  *
    1031             :  * Lockd stuffs a "host" pointer into this.
    1032             :  */
    1033           1 : typedef struct files_struct *fl_owner_t;
    1034           1 : 
    1035             : struct file_lock_operations {
    1036             :         void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
    1037             :         void (*fl_release_private)(struct file_lock *);
    1038             : };
    1039           1 : 
    1040             : struct lock_manager_operations {
    1041             :         int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
    1042             :         void (*fl_notify)(struct file_lock *);  /* unblock callback */
    1043             :         int (*fl_grant)(struct file_lock *, struct file_lock *, int);
    1044             :         void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
    1045             :         void (*fl_release_private)(struct file_lock *);
    1046             :         void (*fl_break)(struct file_lock *);
    1047             :         int (*fl_mylease)(struct file_lock *, struct file_lock *);
    1048             :         int (*fl_change)(struct file_lock **, int);
    1049             : };
    1050             : 
    1051             : struct lock_manager {
    1052             :         struct list_head list;
    1053             : };
    1054             : 
    1055             : void locks_start_grace(struct lock_manager *);
    1056             : void locks_end_grace(struct lock_manager *);
    1057             : int locks_in_grace(void);
    1058             : 
    1059             : /* that will die - we need it for nfs_lock_info */
    1060             : #include <linux/nfs_fs_i.h>
    1061             : 
    1062             : struct file_lock {
    1063             :         struct file_lock *fl_next;      /* singly linked list for this inode  */
    1064             :         struct list_head fl_link;       /* doubly linked list of all locks */
    1065             :         struct list_head fl_block;      /* circular list of blocked processes */
    1066             :         fl_owner_t fl_owner;
    1067             :         unsigned char fl_flags;
    1068             :         unsigned char fl_type;
    1069             :         unsigned int fl_pid;
    1070             :         struct pid *fl_nspid;
    1071             :         wait_queue_head_t fl_wait;
    1072             :         struct file *fl_file;
    1073             :         loff_t fl_start;
    1074             :         loff_t fl_end;
    1075             : 
    1076             :         struct fasync_struct *  fl_fasync; /* for lease break notifications */
    1077             :         unsigned long fl_break_time;    /* for nonblocking lease breaks */
    1078             : 
    1079             :         const struct file_lock_operations *fl_ops;      /* Callbacks for filesystems */
    1080             :         const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */
    1081             :         union {
    1082             :                 struct nfs_lock_info    nfs_fl;
    1083             :                 struct nfs4_lock_info   nfs4_fl;
    1084             :                 struct {
    1085             :                         struct list_head link;  /* link in AFS vnode's pending_locks list */
    1086             :                         int state;              /* state of grant or error if -ve */
    1087             :                 } afs;
    1088             :         } fl_u;
    1089             : };
    1090             : 
    1091             : /* The following constant reflects the upper bound of the file/locking space */
    1092             : #ifndef OFFSET_MAX
    1093             : #define INT_LIMIT(x)    (~((x)1 << (sizeof(x)*8 - 1)))
    1094             : #define OFFSET_MAX      INT_LIMIT(loff_t)
    1095             : #define OFFT_OFFSET_MAX INT_LIMIT(off_t)
    1096             : #endif
    1097             : 
    1098             : #include <linux/fcntl.h>
    1099             : 
    1100             : extern void send_sigio(struct fown_struct *fown, int fd, int band);
    1101             : 
    1102             : #ifdef CONFIG_FILE_LOCKING
    1103             : extern int fcntl_getlk(struct file *, struct flock __user *);
    1104             : extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
    1105             :                         struct flock __user *);
    1106             : 
    1107             : #if BITS_PER_LONG == 32
    1108             : extern int fcntl_getlk64(struct file *, struct flock64 __user *);
    1109             : extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
    1110             :                         struct flock64 __user *);
    1111             : #endif
    1112             : 
    1113             : extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
    1114             : extern int fcntl_getlease(struct file *filp);
    1115             : 
    1116             : /* fs/locks.c */
    1117             : extern void locks_init_lock(struct file_lock *);
    1118             : extern void locks_copy_lock(struct file_lock *, struct file_lock *);
    1119             : extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
    1120             : extern void locks_remove_posix(struct file *, fl_owner_t);
    1121             : extern void locks_remove_flock(struct file *);
    1122             : extern void locks_release_private(struct file_lock *);
    1123             : extern void posix_test_lock(struct file *, struct file_lock *);
    1124             : extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
    1125             : extern int posix_lock_file_wait(struct file *, struct file_lock *);
    1126             : extern int posix_unblock_lock(struct file *, struct file_lock *);
    1127             : extern int vfs_test_lock(struct file *, struct file_lock *);
    1128             : extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
    1129             : extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
    1130             : extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
    1131             : extern int __break_lease(struct inode *inode, unsigned int flags);
    1132             : extern void lease_get_mtime(struct inode *, struct timespec *time);
    1133             : extern int generic_setlease(struct file *, long, struct file_lock **);
    1134             : extern int vfs_setlease(struct file *, long, struct file_lock **);
    1135             : extern int lease_modify(struct file_lock **, int);
    1136             : extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
    1137             : extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
    1138           1 : #else /* !CONFIG_FILE_LOCKING */
    1139             : static inline int fcntl_getlk(struct file *file, struct flock __user *user)
    1140             : {
    1141             :         return -EINVAL;
    1142             : }
    1143             : 
    1144             : static inline int fcntl_setlk(unsigned int fd, struct file *file,
    1145             :                               unsigned int cmd, struct flock __user *user)
    1146             : {
    1147             :         return -EACCES;
    1148             : }
    1149             : 
    1150             : #if BITS_PER_LONG == 32
    1151             : static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user)
    1152             : {
    1153             :         return -EINVAL;
    1154             : }
    1155             : 
    1156             : static inline int fcntl_setlk64(unsigned int fd, struct file *file,
    1157             :                                 unsigned int cmd, struct flock64 __user *user)
    1158             : {
    1159             :         return -EACCES;
    1160             : }
    1161             : #endif
    1162             : static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
    1163             : {
    1164             :         return 0;
    1165             : }
    1166             : 
    1167             : static inline int fcntl_getlease(struct file *filp)
    1168             : {
    1169             :         return 0;
    1170             : }
    1171             : 
    1172             : static inline void locks_init_lock(struct file_lock *fl)
    1173             : {
    1174             :         return;
    1175             : }
    1176             : 
    1177             : static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl)
    1178             : {
    1179             :         return;
    1180             : }
    1181             : 
    1182             : static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
    1183             : {
    1184             :         return;
    1185             : }
    1186             : 
    1187             : static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
    1188             : {
    1189             :         return;
    1190             : }
    1191             : 
    1192             : static inline void locks_remove_flock(struct file *filp)
    1193             : {
    1194             :         return;
    1195             : }
    1196             : 
    1197             : static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
    1198             : {
    1199             :         return;
    1200             : }
    1201             : 
    1202             : static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
    1203             :                                   struct file_lock *conflock)
    1204             : {
    1205             :         return -ENOLCK;
    1206             : }
    1207             : 
    1208             : static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
    1209             : {
    1210             :         return -ENOLCK;
    1211             : }
    1212             : 
    1213             : static inline int posix_unblock_lock(struct file *filp,
    1214             :                                      struct file_lock *waiter)
    1215             : {
    1216             :         return -ENOENT;
    1217             : }
    1218             : 
    1219             : static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
    1220             : {
    1221             :         return 0;
    1222             : }
    1223             : 
    1224             : static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
    1225             :                                 struct file_lock *fl, struct file_lock *conf)
    1226             : {
    1227             :         return -ENOLCK;
    1228             : }
    1229             : 
    1230             : static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
    1231             : {
    1232             :         return 0;
    1233             : }
    1234             : 
    1235             : static inline int flock_lock_file_wait(struct file *filp,
    1236             :                                        struct file_lock *request)
    1237             : {
    1238             :         return -ENOLCK;
    1239             : }
    1240             : 
    1241             : static inline int __break_lease(struct inode *inode, unsigned int mode)
    1242             : {
    1243             :         return 0;
    1244             : }
    1245             : 
    1246             : static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
    1247             : {
    1248             :         return;
    1249             : }
    1250             : 
    1251             : static inline int generic_setlease(struct file *filp, long arg,
    1252             :                                     struct file_lock **flp)
    1253             : {
    1254             :         return -EINVAL;
    1255             : }
    1256             : 
    1257             : static inline int vfs_setlease(struct file *filp, long arg,
    1258             :                                struct file_lock **lease)
    1259             : {
    1260             :         return -EINVAL;
    1261             : }
    1262             : 
    1263             : static inline int lease_modify(struct file_lock **before, int arg)
    1264             : {
    1265             :         return -EINVAL;
    1266             : }
    1267             : 
    1268             : static inline int lock_may_read(struct inode *inode, loff_t start,
    1269             :                                 unsigned long len)
    1270             : {
    1271             :         return 1;
    1272             : }
    1273             : 
    1274             : static inline int lock_may_write(struct inode *inode, loff_t start,
    1275             :                                  unsigned long len)
    1276             : {
    1277             :         return 1;
    1278             : }
    1279             : 
    1280             : #endif /* !CONFIG_FILE_LOCKING */
    1281             : 
    1282             : 
    1283             : struct fasync_struct {
    1284             :         int     magic;
    1285             :         int     fa_fd;
    1286             :         struct  fasync_struct   *fa_next; /* singly linked list */
    1287             :         struct  file            *fa_file;
    1288             : };
    1289             : 
    1290             : #define FASYNC_MAGIC 0x4601
    1291             : 
    1292             : /* SMP safe fasync helpers: */
    1293             : extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
    1294             : /* can be called from interrupts */
    1295             : extern void kill_fasync(struct fasync_struct **, int, int);
    1296             : /* only for net: no internal synchronization */
    1297             : extern void __kill_fasync(struct fasync_struct *, int, int);
    1298             : 
    1299             : extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
    1300             : extern int f_setown(struct file *filp, unsigned long arg, int force);
    1301             : extern void f_delown(struct file *filp);
    1302             : extern pid_t f_getown(struct file *filp);
    1303             : extern int send_sigurg(struct fown_struct *fown);
    1304             : 
    1305             : /*
    1306             :  *      Umount options
    1307             :  */
    1308             : 
    1309             : #define MNT_FORCE       0x00000001      /* Attempt to forcibily umount */
    1310             : #define MNT_DETACH      0x00000002      /* Just detach from the tree */
    1311             : #define MNT_EXPIRE      0x00000004      /* Mark for expiry */
    1312             : #define UMOUNT_NOFOLLOW 0x00000008      /* Don't follow symlink on umount */
    1313             : #define UMOUNT_UNUSED   0x80000000      /* Flag guaranteed to be unused */
    1314             : 
    1315             : extern struct list_head super_blocks;
    1316             : extern spinlock_t sb_lock;
    1317           5 : 
    1318             : #define sb_entry(list)  list_entry((list), struct super_block, s_list)
    1319             : #define S_BIAS (1<<30)
    1320             : struct super_block {
    1321             :         struct list_head        s_list;         /* Keep this first */
    1322             :         dev_t                   s_dev;          /* search index; _not_ kdev_t */
    1323             :         unsigned long           s_blocksize;
    1324             :         unsigned char           s_blocksize_bits;
    1325             :         unsigned char           s_dirt;
    1326             :         loff_t                  s_maxbytes;     /* Max file size */
    1327             :         struct file_system_type *s_type;
    1328             :         const struct super_operations   *s_op;
    1329             :         const struct dquot_operations   *dq_op;
    1330             :         const struct quotactl_ops       *s_qcop;
    1331             :         const struct export_operations *s_export_op;
    1332             :         unsigned long           s_flags;
    1333             :         unsigned long           s_magic;
    1334             :         struct dentry           *s_root;
    1335             :         struct rw_semaphore     s_umount;
    1336             :         struct mutex            s_lock;
    1337             :         int                     s_count;
    1338             :         int                     s_need_sync;
    1339             :         atomic_t                s_active;
    1340             : #ifdef CONFIG_SECURITY
    1341             :         void                    *s_security;
    1342             : #endif
    1343             :         struct xattr_handler    **s_xattr;
    1344             : 
    1345             :         struct list_head        s_inodes;       /* all inodes */
    1346             :         struct hlist_head       s_anon;         /* anonymous dentries for (nfs) exporting */
    1347             :         struct list_head        s_files;
    1348             :         /* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */
    1349             :         struct list_head        s_dentry_lru;   /* unused dentry lru */
    1350             :         int                     s_nr_dentry_unused;     /* # of dentry on lru */
    1351             : 
    1352             :         struct block_device     *s_bdev;
    1353             :         struct backing_dev_info *s_bdi;
    1354             :         struct mtd_info         *s_mtd;
    1355             :         struct list_head        s_instances;
    1356             :         struct quota_info       s_dquot;        /* Diskquota specific options */
    1357             : 
    1358             :         int                     s_frozen;
    1359             :         wait_queue_head_t       s_wait_unfrozen;
    1360             : 
    1361             :         char s_id[32];                          /* Informational name */
    1362             : 
    1363             :         void                    *s_fs_info;     /* Filesystem private info */
    1364             :         fmode_t                 s_mode;
    1365             : 
    1366             :         /*
    1367             :          * The next field is for VFS *only*. No filesystems have any business
    1368             :          * even looking at it. You had been warned.
    1369             :          */
    1370             :         struct mutex s_vfs_rename_mutex;        /* Kludge */
    1371             : 
    1372             :         /* Granularity of c/m/atime in ns.
    1373             :            Cannot be worse than a second */
    1374             :         u32                s_time_gran;
    1375             : 
    1376             :         /*
    1377             :          * Filesystem subtype.  If non-empty the filesystem type field
    1378             :          * in /proc/mounts will be "type.subtype"
    1379             :          */
    1380             :         char *s_subtype;
    1381             : 
    1382             :         /*
    1383             :          * Saved mount options for lazy filesystems using
    1384             :          * generic_show_options()
    1385             :          */
    1386             :         char *s_options;
    1387             : };
    1388             : 
    1389             : extern struct timespec current_fs_time(struct super_block *sb);
    1390             : 
    1391             : /*
    1392             :  * Snapshotting support.
    1393             :  */
    1394             : enum {
    1395             :         SB_UNFROZEN = 0,
    1396             :         SB_FREEZE_WRITE = 1,
    1397             :         SB_FREEZE_TRANS = 2,
    1398             : };
    1399             : 
    1400             : #define vfs_check_frozen(sb, level) \
    1401             :         wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
    1402             : 
    1403             : #define get_fs_excl() atomic_inc(&current->fs_excl)
    1404             : #define put_fs_excl() atomic_dec(&current->fs_excl)
    1405             : #define has_fs_excl() atomic_read(&current->fs_excl)
    1406             : 
    1407             : #define is_owner_or_cap(inode)  \
    1408             :         ((current_fsuid() == (inode)->i_uid) || capable(CAP_FOWNER))
    1409             : 
    1410             : /* not quite ready to be deprecated, but... */
    1411             : extern void lock_super(struct super_block *);
    1412             : extern void unlock_super(struct super_block *);
    1413             : 
    1414             : /*
    1415             :  * VFS helper functions..
    1416             :  */
    1417             : extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
    1418             : extern int vfs_mkdir(struct inode *, struct dentry *, int);
    1419             : extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
    1420             : extern int vfs_symlink(struct inode *, struct dentry *, const char *);
    1421             : extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
    1422             : extern int vfs_rmdir(struct inode *, struct dentry *);
    1423             : extern int vfs_unlink(struct inode *, struct dentry *);
    1424             : extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
    1425             : 
    1426             : /*
    1427             :  * VFS dentry helper functions.
    1428             :  */
    1429             : extern void dentry_unhash(struct dentry *dentry);
    1430             : 
    1431             : /*
    1432             :  * VFS file helper functions.
    1433             :  */
    1434             : extern int file_permission(struct file *, int);
    1435           1 : 
    1436             : /*
    1437             :  * VFS FS_IOC_FIEMAP helper definitions.
    1438             :  */
    1439             : struct fiemap_extent_info {
    1440             :         unsigned int fi_flags;          /* Flags as passed from user */
    1441             :         unsigned int fi_extents_mapped; /* Number of mapped extents */
    1442             :         unsigned int fi_extents_max;    /* Size of fiemap_extent array */
    1443             :         struct fiemap_extent *fi_extents_start; /* Start of fiemap_extent
    1444             :                                                  * array */
    1445             : };
    1446             : int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
    1447             :                             u64 phys, u64 len, u32 flags);
    1448             : int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
    1449             : 
    1450             : /*
    1451             :  * File types
    1452             :  *
    1453             :  * NOTE! These match bits 12..15 of stat.st_mode
    1454             :  * (ie "(i_mode >> 12) & 15").
    1455             :  */
    1456             : #define DT_UNKNOWN      0
    1457             : #define DT_FIFO         1
    1458             : #define DT_CHR          2
    1459             : #define DT_DIR          4
    1460             : #define DT_BLK          6
    1461             : #define DT_REG          8
    1462             : #define DT_LNK          10
    1463             : #define DT_SOCK         12
    1464             : #define DT_WHT          14
    1465             : 
    1466             : /*
    1467             :  * This is the "filldir" function type, used by readdir() to let
    1468             :  * the kernel specify what kind of dirent layout it wants to have.
    1469             :  * This allows the kernel to read directories into kernel space or
    1470             :  * to have different dirent layouts depending on the binary type.
    1471             :  */
    1472             : typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
    1473             : struct block_device_operations;
    1474           1 : 
    1475             : /* These macros are for out of kernel modules to test that
    1476             :  * the kernel supports the unlocked_ioctl and compat_ioctl
    1477             :  * fields in struct file_operations. */
    1478             : #define HAVE_COMPAT_IOCTL 1
    1479             : #define HAVE_UNLOCKED_IOCTL 1
    1480             : 
    1481             : /*
    1482             :  * NOTE:
    1483             :  * read, write, poll, fsync, readv, writev, unlocked_ioctl and compat_ioctl
    1484             :  * can be called without the big kernel lock held in all filesystems.
    1485             :  */
    1486             : struct file_operations {
    1487             :         struct module *owner;
    1488             :         loff_t (*llseek) (struct file *, loff_t, int);
    1489             :         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    1490             :         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    1491             :         ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    1492             :         ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    1493             :         int (*readdir) (struct file *, void *, filldir_t);
    1494             :         unsigned int (*poll) (struct file *, struct poll_table_struct *);
    1495             :         int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
    1496             :         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    1497             :         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    1498             :         int (*mmap) (struct file *, struct vm_area_struct *);
    1499             :         int (*open) (struct inode *, struct file *);
    1500             :         int (*flush) (struct file *, fl_owner_t id);
    1501             :         int (*release) (struct inode *, struct file *);
    1502             :         int (*fsync) (struct file *, struct dentry *, int datasync);
    1503             :         int (*aio_fsync) (struct kiocb *, int datasync);
    1504             :         int (*fasync) (int, struct file *, int);
    1505             :         int (*lock) (struct file *, int, struct file_lock *);
    1506             :         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    1507             :         unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    1508             :         int (*check_flags)(int);
    1509             :         int (*flock) (struct file *, int, struct file_lock *);
    1510             :         ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    1511             :         ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    1512             :         int (*setlease)(struct file *, long, struct file_lock **);
    1513             : };
    1514           1 : 
    1515             : struct inode_operations {
    1516             :         int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
    1517             :         struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
    1518             :         int (*link) (struct dentry *,struct inode *,struct dentry *);
    1519             :         int (*unlink) (struct inode *,struct dentry *);
    1520             :         int (*symlink) (struct inode *,struct dentry *,const char *);
    1521             :         int (*mkdir) (struct inode *,struct dentry *,int);
    1522             :         int (*rmdir) (struct inode *,struct dentry *);
    1523             :         int (*mknod) (struct inode *,struct dentry *,int,dev_t);
    1524             :         int (*rename) (struct inode *, struct dentry *,
    1525             :                         struct inode *, struct dentry *);
    1526             :         int (*readlink) (struct dentry *, char __user *,int);
    1527             :         void * (*follow_link) (struct dentry *, struct nameidata *);
    1528             :         void (*put_link) (struct dentry *, struct nameidata *, void *);
    1529             :         void (*truncate) (struct inode *);
    1530             :         int (*permission) (struct inode *, int);
    1531             :         int (*check_acl)(struct inode *, int);
    1532             :         int (*setattr) (struct dentry *, struct iattr *);
    1533             :         int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
    1534             :         int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
    1535             :         ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
    1536             :         ssize_t (*listxattr) (struct dentry *, char *, size_t);
    1537             :         int (*removexattr) (struct dentry *, const char *);
    1538             :         void (*truncate_range)(struct inode *, loff_t, loff_t);
    1539             :         long (*fallocate)(struct inode *inode, int mode, loff_t offset,
    1540             :                           loff_t len);
    1541             :         int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
    1542             :                       u64 len);
    1543             : };
    1544             : 
    1545             : struct seq_file;
    1546             : 
    1547             : ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
    1548             :                                 unsigned long nr_segs, unsigned long fast_segs,
    1549             :                                 struct iovec *fast_pointer,
    1550             :                                 struct iovec **ret_pointer);
    1551             : 
    1552             : extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
    1553             : extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
    1554             : extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
    1555             :                 unsigned long, loff_t *);
    1556             : extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
    1557           1 :                 unsigned long, loff_t *);
    1558             : 
    1559             : struct super_operations {
    1560             :         struct inode *(*alloc_inode)(struct super_block *sb);
    1561             :         void (*destroy_inode)(struct inode *);
    1562             : 
    1563             :         void (*dirty_inode) (struct inode *);
    1564             :         int (*write_inode) (struct inode *, int);
    1565             :         void (*drop_inode) (struct inode *);
    1566             :         void (*delete_inode) (struct inode *);
    1567             :         void (*put_super) (struct super_block *);
    1568             :         void (*write_super) (struct super_block *);
    1569             :         int (*sync_fs)(struct super_block *sb, int wait);
    1570             :         int (*freeze_fs) (struct super_block *);
    1571             :         int (*unfreeze_fs) (struct super_block *);
    1572             :         int (*statfs) (struct dentry *, struct kstatfs *);
    1573             :         int (*remount_fs) (struct super_block *, int *, char *);
    1574             :         void (*clear_inode) (struct inode *);
    1575             :         void (*umount_begin) (struct super_block *);
    1576             : 
    1577             :         int (*show_options)(struct seq_file *, struct vfsmount *);
    1578             :         int (*show_stats)(struct seq_file *, struct vfsmount *);
    1579             : #ifdef CONFIG_QUOTA
    1580             :         ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
    1581             :         ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
    1582             : #endif
    1583             :         int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
    1584             : };
    1585             : 
    1586             : /*
    1587             :  * Inode state bits.  Protected by inode_lock.
    1588             :  *
    1589             :  * Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
    1590             :  * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
    1591             :  *
    1592             :  * Four bits define the lifetime of an inode.  Initially, inodes are I_NEW,
    1593             :  * until that flag is cleared.  I_WILL_FREE, I_FREEING and I_CLEAR are set at
    1594             :  * various stages of removing an inode.
    1595             :  *
    1596             :  * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
    1597             :  *
    1598             :  * I_DIRTY_SYNC         Inode is dirty, but doesn't have to be written on
    1599             :  *                      fdatasync().  i_atime is the usual cause.
    1600             :  * I_DIRTY_DATASYNC     Data-related inode changes pending. We keep track of
    1601             :  *                      these changes separately from I_DIRTY_SYNC so that we
    1602             :  *                      don't have to write inode on fdatasync() when only
    1603             :  *                      mtime has changed in it.
    1604             :  * I_DIRTY_PAGES        Inode has dirty pages.  Inode itself may be clean.
    1605             :  * I_NEW                Serves as both a mutex and completion notification.
    1606             :  *                      New inodes set I_NEW.  If two processes both create
    1607             :  *                      the same inode, one of them will release its inode and
    1608             :  *                      wait for I_NEW to be released before returning.
    1609             :  *                      Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
    1610             :  *                      also cause waiting on I_NEW, without I_NEW actually
    1611             :  *                      being set.  find_inode() uses this to prevent returning
    1612             :  *                      nearly-dead inodes.
    1613             :  * I_WILL_FREE          Must be set when calling write_inode_now() if i_count
    1614             :  *                      is zero.  I_FREEING must be set when I_WILL_FREE is
    1615             :  *                      cleared.
    1616             :  * I_FREEING            Set when inode is about to be freed but still has dirty
    1617             :  *                      pages or buffers attached or the inode itself is still
    1618             :  *                      dirty.
    1619             :  * I_CLEAR              Set by clear_inode().  In this state the inode is clean
    1620             :  *                      and can be destroyed.
    1621             :  *
    1622             :  *                      Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
    1623             :  *                      prohibited for many purposes.  iget() must wait for
    1624             :  *                      the inode to be completely released, then create it
    1625             :  *                      anew.  Other functions will just ignore such inodes,
    1626             :  *                      if appropriate.  I_NEW is used for waiting.
    1627             :  *
    1628             :  * I_SYNC               Synchonized write of dirty inode data.  The bits is
    1629             :  *                      set during data writeback, and cleared with a wakeup
    1630             :  *                      on the bit address once it is done.
    1631             :  *
    1632             :  * Q: What is the difference between I_WILL_FREE and I_FREEING?
    1633             :  */
    1634             : #define I_DIRTY_SYNC            1
    1635             : #define I_DIRTY_DATASYNC        2
    1636             : #define I_DIRTY_PAGES           4
    1637             : #define __I_NEW                 3
    1638             : #define I_NEW                   (1 << __I_NEW)
    1639             : #define I_WILL_FREE             16
    1640             : #define I_FREEING               32
    1641             : #define I_CLEAR                 64
    1642             : #define __I_SYNC                7
    1643             : #define I_SYNC                  (1 << __I_SYNC)
    1644             : 
    1645             : #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
    1646             : 
    1647             : extern void __mark_inode_dirty(struct inode *, int);
    1648             : static inline void mark_inode_dirty(struct inode *inode)
    1649             : {
    1650             :         __mark_inode_dirty(inode, I_DIRTY);
    1651             : }
    1652             : 
    1653             : static inline void mark_inode_dirty_sync(struct inode *inode)
    1654             : {
    1655             :         __mark_inode_dirty(inode, I_DIRTY_SYNC);
    1656             : }
    1657             : 
    1658             : /**
    1659             :  * inc_nlink - directly increment an inode's link count
    1660             :  * @inode: inode
    1661             :  *
    1662             :  * This is a low-level filesystem helper to replace any
    1663             :  * direct filesystem manipulation of i_nlink.  Currently,
    1664             :  * it is only here for parity with dec_nlink().
    1665             :  */
    1666             : static inline void inc_nlink(struct inode *inode)
    1667             : {
    1668             :         inode->i_nlink++;
    1669             : }
    1670             : 
    1671             : static inline void inode_inc_link_count(struct inode *inode)
    1672             : {
    1673             :         inc_nlink(inode);
    1674             :         mark_inode_dirty(inode);
    1675             : }
    1676             : 
    1677             : /**
    1678             :  * drop_nlink - directly drop an inode's link count
    1679             :  * @inode: inode
    1680             :  *
    1681             :  * This is a low-level filesystem helper to replace any
    1682             :  * direct filesystem manipulation of i_nlink.  In cases
    1683             :  * where we are attempting to track writes to the
    1684             :  * filesystem, a decrement to zero means an imminent
    1685             :  * write when the file is truncated and actually unlinked
    1686             :  * on the filesystem.
    1687             :  */
    1688             : static inline void drop_nlink(struct inode *inode)
    1689             : {
    1690             :         inode->i_nlink--;
    1691             : }
    1692             : 
    1693             : /**
    1694             :  * clear_nlink - directly zero an inode's link count
    1695             :  * @inode: inode
    1696             :  *
    1697             :  * This is a low-level filesystem helper to replace any
    1698             :  * direct filesystem manipulation of i_nlink.  See
    1699             :  * drop_nlink() for why we care about i_nlink hitting zero.
    1700             :  */
    1701             : static inline void clear_nlink(struct inode *inode)
    1702             : {
    1703             :         inode->i_nlink = 0;
    1704             : }
    1705             : 
    1706             : static inline void inode_dec_link_count(struct inode *inode)
    1707             : {
    1708             :         drop_nlink(inode);
    1709             :         mark_inode_dirty(inode);
    1710             : }
    1711             : 
    1712             : /**
    1713             :  * inode_inc_iversion - increments i_version
    1714             :  * @inode: inode that need to be updated
    1715             :  *
    1716             :  * Every time the inode is modified, the i_version field will be incremented.
    1717             :  * The filesystem has to be mounted with i_version flag
    1718             :  */
    1719             : 
    1720             : static inline void inode_inc_iversion(struct inode *inode)
    1721             : {
    1722             :        spin_lock(&inode->i_lock);
    1723             :        inode->i_version++;
    1724             :        spin_unlock(&inode->i_lock);
    1725             : }
    1726             : 
    1727             : extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
    1728             : static inline void file_accessed(struct file *file)
    1729             : {
    1730             :         if (!(file->f_flags & O_NOATIME))
    1731             :                 touch_atime(file->f_path.mnt, file->f_path.dentry);
    1732             : }
    1733             : 
    1734             : int sync_inode(struct inode *inode, struct writeback_control *wbc);
    1735           1 : 
    1736             : struct file_system_type {
    1737             :         const char *name;
    1738             :         int fs_flags;
    1739             :         int (*get_sb) (struct file_system_type *, int,
    1740             :                        const char *, void *, struct vfsmount *);
    1741             :         void (*kill_sb) (struct super_block *);
    1742             :         struct module *owner;
    1743             :         struct file_system_type * next;
    1744             :         struct list_head fs_supers;
    1745             : 
    1746             :         struct lock_class_key s_lock_key;
    1747             :         struct lock_class_key s_umount_key;
    1748             : 
    1749             :         struct lock_class_key i_lock_key;
    1750             :         struct lock_class_key i_mutex_key;
    1751             :         struct lock_class_key i_mutex_dir_key;
    1752             :         struct lock_class_key i_alloc_sem_key;
    1753             : };
    1754             : 
    1755             : extern int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,
    1756             :         int (*fill_super)(struct super_block *, void *, int),
    1757             :         struct vfsmount *mnt);
    1758             : extern int get_sb_bdev(struct file_system_type *fs_type,
    1759             :         int flags, const char *dev_name, void *data,
    1760             :         int (*fill_super)(struct super_block *, void *, int),
    1761             :         struct vfsmount *mnt);
    1762             : extern int get_sb_single(struct file_system_type *fs_type,
    1763             :         int flags, void *data,
    1764             :         int (*fill_super)(struct super_block *, void *, int),
    1765             :         struct vfsmount *mnt);
    1766             : extern int get_sb_nodev(struct file_system_type *fs_type,
    1767             :         int flags, void *data,
    1768             :         int (*fill_super)(struct super_block *, void *, int),
    1769             :         struct vfsmount *mnt);
    1770             : void generic_shutdown_super(struct super_block *sb);
    1771             : void kill_block_super(struct super_block *sb);
    1772             : void kill_anon_super(struct super_block *sb);
    1773             : void kill_litter_super(struct super_block *sb);
    1774             : void deactivate_super(struct super_block *sb);
    1775             : void deactivate_locked_super(struct super_block *sb);
    1776             : int set_anon_super(struct super_block *s, void *data);
    1777             : struct super_block *sget(struct file_system_type *type,
    1778             :                         int (*test)(struct super_block *,void *),
    1779             :                         int (*set)(struct super_block *,void *),
    1780             :                         void *data);
    1781             : extern int get_sb_pseudo(struct file_system_type *, char *,
    1782             :         const struct super_operations *ops, unsigned long,
    1783             :         struct vfsmount *mnt);
    1784             : extern void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
    1785             : int __put_super_and_need_restart(struct super_block *sb);
    1786             : void put_super(struct super_block *sb);
    1787             : 
    1788             : /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
    1789             : #define fops_get(fops) \
    1790             :         (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
    1791             : #define fops_put(fops) \
    1792             :         do { if (fops) module_put((fops)->owner); } while(0)
    1793             : 
    1794             : extern int register_filesystem(struct file_system_type *);
    1795             : extern int unregister_filesystem(struct file_system_type *);
    1796             : extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
    1797             : #define kern_mount(type) kern_mount_data(type, NULL)
    1798             : extern int may_umount_tree(struct vfsmount *);
    1799             : extern int may_umount(struct vfsmount *);
    1800             : extern long do_mount(char *, char *, char *, unsigned long, void *);
    1801             : extern struct vfsmount *collect_mounts(struct path *);
    1802             : extern void drop_collected_mounts(struct vfsmount *);
    1803             : 
    1804             : extern int vfs_statfs(struct dentry *, struct kstatfs *);
    1805             : 
    1806             : extern int current_umask(void);
    1807             : 
    1808             : /* /sys/fs */
    1809             : extern struct kobject *fs_kobj;
    1810             : 
    1811             : extern int rw_verify_area(int, struct file *, loff_t *, size_t);
    1812             : 
    1813             : #define FLOCK_VERIFY_READ  1
    1814             : #define FLOCK_VERIFY_WRITE 2
    1815             : 
    1816             : #ifdef CONFIG_FILE_LOCKING
    1817             : extern int locks_mandatory_locked(struct inode *);
    1818             : extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
    1819             : 
    1820             : /*
    1821             :  * Candidates for mandatory locking have the setgid bit set
    1822             :  * but no group execute bit -  an otherwise meaningless combination.
    1823             :  */
    1824             : 
    1825             : static inline int __mandatory_lock(struct inode *ino)
    1826             : {
    1827             :         return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
    1828             : }
    1829             : 
    1830             : /*
    1831             :  * ... and these candidates should be on MS_MANDLOCK mounted fs,
    1832             :  * otherwise these will be advisory locks
    1833             :  */
    1834             : 
    1835             : static inline int mandatory_lock(struct inode *ino)
    1836             : {
    1837             :         return IS_MANDLOCK(ino) && __mandatory_lock(ino);
    1838             : }
    1839             : 
    1840             : static inline int locks_verify_locked(struct inode *inode)
    1841             : {
    1842             :         if (mandatory_lock(inode))
    1843             :                 return locks_mandatory_locked(inode);
    1844             :         return 0;
    1845             : }
    1846             : 
    1847             : static inline int locks_verify_truncate(struct inode *inode,
    1848             :                                     struct file *filp,
    1849             :                                     loff_t size)
    1850             : {
    1851             :         if (inode->i_flock && mandatory_lock(inode))
    1852             :                 return locks_mandatory_area(
    1853             :                         FLOCK_VERIFY_WRITE, inode, filp,
    1854             :                         size < inode->i_size ? size : inode->i_size,
    1855             :                         (size < inode->i_size ? inode->i_size - size
    1856             :                          : size - inode->i_size)
    1857             :                 );
    1858             :         return 0;
    1859             : }
    1860             : 
    1861             : static inline int break_lease(struct inode *inode, unsigned int mode)
    1862             : {
    1863             :         if (inode->i_flock)
    1864             :                 return __break_lease(inode, mode);
    1865             :         return 0;
    1866             : }
    1867             : #else /* !CONFIG_FILE_LOCKING */
    1868             : static inline int locks_mandatory_locked(struct inode *inode)
    1869             : {
    1870             :         return 0;
    1871             : }
    1872             : 
    1873             : static inline int locks_mandatory_area(int rw, struct inode *inode,
    1874             :                                        struct file *filp, loff_t offset,
    1875             :                                        size_t count)
    1876             : {
    1877             :         return 0;
    1878             : }
    1879             : 
    1880             : static inline int __mandatory_lock(struct inode *inode)
    1881             : {
    1882             :         return 0;
    1883             : }
    1884             : 
    1885             : static inline int mandatory_lock(struct inode *inode)
    1886             : {
    1887             :         return 0;
    1888             : }
    1889             : 
    1890             : static inline int locks_verify_locked(struct inode *inode)
    1891             : {
    1892             :         return 0;
    1893             : }
    1894             : 
    1895             : static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
    1896             :                                         size_t size)
    1897             : {
    1898             :         return 0;
    1899             : }
    1900             : 
    1901             : static inline int break_lease(struct inode *inode, unsigned int mode)
    1902             : {
    1903             :         return 0;
    1904             : }
    1905             : 
    1906             : #endif /* CONFIG_FILE_LOCKING */
    1907             : 
    1908             : /* fs/open.c */
    1909             : 
    1910             : extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
    1911             :                        struct file *filp);
    1912             : extern int do_fallocate(struct file *file, int mode, loff_t offset,
    1913             :                         loff_t len);
    1914             : extern long do_sys_open(int dfd, const char __user *filename, int flags,
    1915             :                         int mode);
    1916             : extern struct file *filp_open(const char *, int, int);
    1917             : extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
    1918             :                                  const struct cred *);
    1919             : extern int filp_close(struct file *, fl_owner_t id);
    1920             : extern char * getname(const char __user *);
    1921             : 
    1922             : /* fs/ioctl.c */
    1923             : 
    1924             : extern int ioctl_preallocate(struct file *filp, void __user *argp);
    1925             : 
    1926             : /* fs/dcache.c */
    1927             : extern void __init vfs_caches_init_early(void);
    1928             : extern void __init vfs_caches_init(unsigned long);
    1929             : 
    1930             : extern struct kmem_cache *names_cachep;
    1931             : 
    1932             : #define __getname_gfp(gfp)      kmem_cache_alloc(names_cachep, (gfp))
    1933             : #define __getname()             __getname_gfp(GFP_KERNEL)
    1934             : #define __putname(name)         kmem_cache_free(names_cachep, (void *)(name))
    1935             : #ifndef CONFIG_AUDITSYSCALL
    1936             : #define putname(name)   __putname(name)
    1937             : #else
    1938             : extern void putname(const char *name);
    1939             : #endif
    1940             : 
    1941             : #ifdef CONFIG_BLOCK
    1942             : extern int register_blkdev(unsigned int, const char *);
    1943             : extern void unregister_blkdev(unsigned int, const char *);
    1944             : extern struct block_device *bdget(dev_t);
    1945             : extern struct block_device *bdgrab(struct block_device *bdev);
    1946             : extern void bd_set_size(struct block_device *, loff_t size);
    1947             : extern void bd_forget(struct inode *inode);
    1948             : extern void bdput(struct block_device *);
    1949             : extern struct block_device *open_by_devnum(dev_t, fmode_t);
    1950             : extern void invalidate_bdev(struct block_device *);
    1951             : extern int sync_blockdev(struct block_device *bdev);
    1952             : extern struct super_block *freeze_bdev(struct block_device *);
    1953             : extern void emergency_thaw_all(void);
    1954             : extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
    1955             : extern int fsync_bdev(struct block_device *);
    1956             : #else
    1957             : static inline void bd_forget(struct inode *inode) {}
    1958             : static inline int sync_blockdev(struct block_device *bdev) { return 0; }
    1959             : static inline void invalidate_bdev(struct block_device *bdev) {}
    1960             : 
    1961             : static inline struct super_block *freeze_bdev(struct block_device *sb)
    1962             : {
    1963             :         return NULL;
    1964             : }
    1965             : 
    1966             : static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
    1967             : {
    1968             :         return 0;
    1969             : }
    1970             : #endif
    1971             : extern int sync_filesystem(struct super_block *);
    1972             : extern const struct file_operations def_blk_fops;
    1973             : extern const struct file_operations def_chr_fops;
    1974             : extern const struct file_operations bad_sock_fops;
    1975             : extern const struct file_operations def_fifo_fops;
    1976             : #ifdef CONFIG_BLOCK
    1977             : extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
    1978             : extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
    1979             : extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
    1980             : extern int blkdev_get(struct block_device *, fmode_t);
    1981             : extern int blkdev_put(struct block_device *, fmode_t);
    1982             : extern int bd_claim(struct block_device *, void *);
    1983             : extern void bd_release(struct block_device *);
    1984             : #ifdef CONFIG_SYSFS
    1985             : extern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);
    1986             : extern void bd_release_from_disk(struct block_device *, struct gendisk *);
    1987             : #else
    1988             : #define bd_claim_by_disk(bdev, holder, disk)    bd_claim(bdev, holder)
    1989             : #define bd_release_from_disk(bdev, disk)        bd_release(bdev)
    1990             : #endif
    1991             : #endif
    1992             : 
    1993             : /* fs/char_dev.c */
    1994             : #define CHRDEV_MAJOR_HASH_SIZE  255
    1995             : extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
    1996             : extern int register_chrdev_region(dev_t, unsigned, const char *);
    1997             : extern int __register_chrdev(unsigned int major, unsigned int baseminor,
    1998             :                              unsigned int count, const char *name,
    1999             :                              const struct file_operations *fops);
    2000             : extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
    2001             :                                 unsigned int count, const char *name);
    2002             : extern void unregister_chrdev_region(dev_t, unsigned);
    2003             : extern void chrdev_show(struct seq_file *,off_t);
    2004             : 
    2005             : static inline int register_chrdev(unsigned int major, const char *name,
    2006             :                                   const struct file_operations *fops)
    2007             : {
    2008             :         return __register_chrdev(major, 0, 256, name, fops);
    2009             : }
    2010             : 
    2011             : static inline void unregister_chrdev(unsigned int major, const char *name)
    2012             : {
    2013             :         __unregister_chrdev(major, 0, 256, name);
    2014             : }
    2015             : 
    2016             : /* fs/block_dev.c */
    2017             : #define BDEVNAME_SIZE   32      /* Largest string for a blockdev identifier */
    2018             : #define BDEVT_SIZE      10      /* Largest string for MAJ:MIN for blkdev */
    2019             : 
    2020             : #ifdef CONFIG_BLOCK
    2021             : #define BLKDEV_MAJOR_HASH_SIZE  255
    2022             : extern const char *__bdevname(dev_t, char *buffer);
    2023             : extern const char *bdevname(struct block_device *bdev, char *buffer);
    2024             : extern struct block_device *lookup_bdev(const char *);
    2025             : extern struct block_device *open_bdev_exclusive(const char *, fmode_t, void *);
    2026             : extern void close_bdev_exclusive(struct block_device *, fmode_t);
    2027             : extern void blkdev_show(struct seq_file *,off_t);
    2028             : 
    2029             : #else
    2030             : #define BLKDEV_MAJOR_HASH_SIZE  0
    2031             : #endif
    2032             : 
    2033             : extern void init_special_inode(struct inode *, umode_t, dev_t);
    2034             : 
    2035             : /* Invalid inode operations -- fs/bad_inode.c */
    2036             : extern void make_bad_inode(struct inode *);
    2037             : extern int is_bad_inode(struct inode *);
    2038             : 
    2039             : extern const struct file_operations read_pipefifo_fops;
    2040             : extern const struct file_operations write_pipefifo_fops;
    2041             : extern const struct file_operations rdwr_pipefifo_fops;
    2042             : 
    2043             : extern int fs_may_remount_ro(struct super_block *);
    2044             : 
    2045             : #ifdef CONFIG_BLOCK
    2046             : /*
    2047             :  * return READ, READA, or WRITE
    2048             :  */
    2049             : #define bio_rw(bio)             ((bio)->bi_rw & (RW_MASK | RWA_MASK))
    2050             : 
    2051             : /*
    2052             :  * return data direction, READ or WRITE
    2053             :  */
    2054             : #define bio_data_dir(bio)       ((bio)->bi_rw & 1)
    2055             : 
    2056             : extern void check_disk_size_change(struct gendisk *disk,
    2057             :                                    struct block_device *bdev);
    2058             : extern int revalidate_disk(struct gendisk *);
    2059             : extern int check_disk_change(struct block_device *);
    2060             : extern int __invalidate_device(struct block_device *);
    2061             : extern int invalidate_partition(struct gendisk *, int);
    2062             : #endif
    2063             : extern int invalidate_inodes(struct super_block *);
    2064             : unsigned long invalidate_mapping_pages(struct address_space *mapping,
    2065             :                                         pgoff_t start, pgoff_t end);
    2066             : 
    2067             : static inline unsigned long __deprecated
    2068             : invalidate_inode_pages(struct address_space *mapping)
    2069             : {
    2070             :         return invalidate_mapping_pages(mapping, 0, ~0UL);
    2071             : }
    2072             : 
    2073             : static inline void invalidate_remote_inode(struct inode *inode)
    2074             : {
    2075             :         if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
    2076             :             S_ISLNK(inode->i_mode))
    2077             :                 invalidate_mapping_pages(inode->i_mapping, 0, -1);
    2078             : }
    2079             : extern int invalidate_inode_pages2(struct address_space *mapping);
    2080             : extern int invalidate_inode_pages2_range(struct address_space *mapping,
    2081             :                                          pgoff_t start, pgoff_t end);
    2082             : extern int write_inode_now(struct inode *, int);
    2083             : extern int filemap_fdatawrite(struct address_space *);
    2084             : extern int filemap_flush(struct address_space *);
    2085             : extern int filemap_fdatawait(struct address_space *);
    2086             : extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
    2087             :                                    loff_t lend);
    2088             : extern int filemap_write_and_wait(struct address_space *mapping);
    2089             : extern int filemap_write_and_wait_range(struct address_space *mapping,
    2090             :                                         loff_t lstart, loff_t lend);
    2091             : extern int __filemap_fdatawrite_range(struct address_space *mapping,
    2092             :                                 loff_t start, loff_t end, int sync_mode);
    2093             : extern int filemap_fdatawrite_range(struct address_space *mapping,
    2094             :                                 loff_t start, loff_t end);
    2095             : 
    2096             : extern int vfs_fsync_range(struct file *file, struct dentry *dentry,
    2097             :                            loff_t start, loff_t end, int datasync);
    2098             : extern int vfs_fsync(struct file *file, struct dentry *dentry, int datasync);
    2099             : extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);
    2100             : extern void sync_supers(void);
    2101             : extern void emergency_sync(void);
    2102             : extern void emergency_remount(void);
    2103             : #ifdef CONFIG_BLOCK
    2104             : extern sector_t bmap(struct inode *, sector_t);
    2105             : #endif
    2106             : extern int notify_change(struct dentry *, struct iattr *);
    2107             : extern int inode_permission(struct inode *, int);
    2108             : extern int generic_permission(struct inode *, int,
    2109             :                 int (*check_acl)(struct inode *, int));
    2110             : 
    2111             : static inline bool execute_ok(struct inode *inode)
    2112             : {
    2113             :         return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
    2114             : }
    2115             : 
    2116             : extern int get_write_access(struct inode *);
    2117             : extern int deny_write_access(struct file *);
    2118             : static inline void put_write_access(struct inode * inode)
    2119             : {
    2120             :         atomic_dec(&inode->i_writecount);
    2121             : }
    2122             : static inline void allow_write_access(struct file *file)
    2123             : {
    2124             :         if (file)
    2125             :                 atomic_inc(&file->f_path.dentry->d_inode->i_writecount);
    2126             : }
    2127             : extern int do_pipe_flags(int *, int);
    2128             : extern struct file *create_read_pipe(struct file *f, int flags);
    2129             : extern struct file *create_write_pipe(int flags);
    2130             : extern void free_write_pipe(struct file *);
    2131             : 
    2132             : extern struct file *do_filp_open(int dfd, const char *pathname,
    2133             :                 int open_flag, int mode, int acc_mode);
    2134             : extern int may_open(struct path *, int, int);
    2135             : 
    2136             : extern int kernel_read(struct file *, loff_t, char *, unsigned long);
    2137             : extern struct file * open_exec(const char *);
    2138             :  
    2139             : /* fs/dcache.c -- generic fs support functions */
    2140             : extern int is_subdir(struct dentry *, struct dentry *);
    2141             : extern ino_t find_inode_number(struct dentry *, struct qstr *);
    2142             : 
    2143             : #include <linux/err.h>
    2144             : 
    2145             : /* needed for stackable file system support */
    2146             : extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
    2147             : 
    2148             : extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
    2149             : 
    2150             : extern int inode_init_always(struct super_block *, struct inode *);
    2151             : extern void inode_init_once(struct inode *);
    2152             : extern void address_space_init_once(struct address_space *mapping);
    2153             : extern void inode_add_to_lists(struct super_block *, struct inode *);
    2154             : extern void iput(struct inode *);
    2155             : extern struct inode * igrab(struct inode *);
    2156             : extern ino_t iunique(struct super_block *, ino_t);
    2157             : extern int inode_needs_sync(struct inode *inode);
    2158             : extern void generic_delete_inode(struct inode *inode);
    2159             : extern void generic_drop_inode(struct inode *inode);
    2160             : extern int generic_detach_inode(struct inode *inode);
    2161             : 
    2162             : extern struct inode *ilookup5_nowait(struct super_block *sb,
    2163             :                 unsigned long hashval, int (*test)(struct inode *, void *),
    2164             :                 void *data);
    2165             : extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
    2166             :                 int (*test)(struct inode *, void *), void *data);
    2167             : extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
    2168             : 
    2169             : extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
    2170             : extern struct inode * iget_locked(struct super_block *, unsigned long);
    2171             : extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
    2172             : extern int insert_inode_locked(struct inode *);
    2173             : extern void unlock_new_inode(struct inode *);
    2174             : 
    2175             : extern void __iget(struct inode * inode);
    2176             : extern void iget_failed(struct inode *);
    2177             : extern void clear_inode(struct inode *);
    2178             : extern void destroy_inode(struct inode *);
    2179             : extern void __destroy_inode(struct inode *);
    2180             : extern struct inode *new_inode(struct super_block *);
    2181             : extern int should_remove_suid(struct dentry *);
    2182             : extern int file_remove_suid(struct file *);
    2183             : 
    2184             : extern void __insert_inode_hash(struct inode *, unsigned long hashval);
    2185             : extern void remove_inode_hash(struct inode *);
    2186             : static inline void insert_inode_hash(struct inode *inode) {
    2187             :         __insert_inode_hash(inode, inode->i_ino);
    2188             : }
    2189             : 
    2190             : extern void file_move(struct file *f, struct list_head *list);
    2191             : extern void file_kill(struct file *f);
    2192             : #ifdef CONFIG_BLOCK
    2193             : struct bio;
    2194             : extern void submit_bio(int, struct bio *);
    2195             : extern int bdev_read_only(struct block_device *);
    2196             : #endif
    2197             : extern int set_blocksize(struct block_device *, int);
    2198             : extern int sb_set_blocksize(struct super_block *, int);
    2199             : extern int sb_min_blocksize(struct super_block *, int);
    2200             : 
    2201             : extern int generic_file_mmap(struct file *, struct vm_area_struct *);
    2202             : extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
    2203             : extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
    2204             : int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
    2205             : extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
    2206             : extern ssize_t __generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long,
    2207             :                 loff_t *);
    2208             : extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
    2209             : extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
    2210             :                 unsigned long *, loff_t, loff_t *, size_t, size_t);
    2211             : extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
    2212             :                 unsigned long, loff_t, loff_t *, size_t, ssize_t);
    2213             : extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
    2214             : extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
    2215             : extern int generic_segment_checks(const struct iovec *iov,
    2216             :                 unsigned long *nr_segs, size_t *count, int access_flags);
    2217             : 
    2218             : /* fs/block_dev.c */
    2219             : extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
    2220             :                                 unsigned long nr_segs, loff_t pos);
    2221             : extern int block_fsync(struct file *filp, struct dentry *dentry, int datasync);
    2222             : 
    2223             : /* fs/splice.c */
    2224             : extern ssize_t generic_file_splice_read(struct file *, loff_t *,
    2225             :                 struct pipe_inode_info *, size_t, unsigned int);
    2226             : extern ssize_t default_file_splice_read(struct file *, loff_t *,
    2227             :                 struct pipe_inode_info *, size_t, unsigned int);
    2228             : extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
    2229             :                 struct file *, loff_t *, size_t, unsigned int);
    2230             : extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
    2231             :                 struct file *out, loff_t *, size_t len, unsigned int flags);
    2232             : extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
    2233             :                 size_t len, unsigned int flags);
    2234             : 
    2235             : extern void
    2236             : file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
    2237             : extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
    2238             : extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
    2239             : extern loff_t generic_file_llseek_unlocked(struct file *file, loff_t offset,
    2240             :                         int origin);
    2241             : extern int generic_file_open(struct inode * inode, struct file * filp);
    2242             : extern int nonseekable_open(struct inode * inode, struct file * filp);
    2243             : 
    2244             : #ifdef CONFIG_FS_XIP
    2245             : extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
    2246             :                              loff_t *ppos);
    2247             : extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
    2248             : extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
    2249             :                               size_t len, loff_t *ppos);
    2250             : extern int xip_truncate_page(struct address_space *mapping, loff_t from);
    2251             : #else
    2252             : static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
    2253             : {
    2254             :         return 0;
    2255             : }
    2256             : #endif
    2257             : 
    2258             : #ifdef CONFIG_BLOCK
    2259             : ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
    2260             :         struct block_device *bdev, const struct iovec *iov, loff_t offset,
    2261             :         unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
    2262             :         int lock_type);
    2263             : 
    2264             : enum {
    2265             :         /* need locking between buffered and direct access */
    2266             :         DIO_LOCKING     = 0x01,
    2267             : 
    2268             :         /* filesystem does not support filling holes */
    2269             :         DIO_SKIP_HOLES  = 0x02,
    2270             : };
    2271             : 
    2272             : static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
    2273             :         struct inode *inode, struct block_device *bdev, const struct iovec *iov,
    2274             :         loff_t offset, unsigned long nr_segs, get_block_t get_block,
    2275             :         dio_iodone_t end_io)
    2276             : {
    2277             :         return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
    2278             :                                     nr_segs, get_block, end_io,
    2279             :                                     DIO_LOCKING | DIO_SKIP_HOLES);
    2280             : }
    2281             : 
    2282             : static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
    2283             :         struct inode *inode, struct block_device *bdev, const struct iovec *iov,
    2284             :         loff_t offset, unsigned long nr_segs, get_block_t get_block,
    2285             :         dio_iodone_t end_io)
    2286             : {
    2287             :         return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
    2288             :                                 nr_segs, get_block, end_io, 0);
    2289             : }
    2290             : #endif
    2291             : 
    2292             : extern const struct file_operations generic_ro_fops;
    2293             : 
    2294             : #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
    2295             : 
    2296             : extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
    2297             : extern int vfs_follow_link(struct nameidata *, const char *);
    2298             : extern int page_readlink(struct dentry *, char __user *, int);
    2299             : extern void *page_follow_link_light(struct dentry *, struct nameidata *);
    2300             : extern void page_put_link(struct dentry *, struct nameidata *, void *);
    2301             : extern int __page_symlink(struct inode *inode, const char *symname, int len,
    2302             :                 int nofs);
    2303             : extern int page_symlink(struct inode *inode, const char *symname, int len);
    2304             : extern const struct inode_operations page_symlink_inode_operations;
    2305             : extern int generic_readlink(struct dentry *, char __user *, int);
    2306             : extern void generic_fillattr(struct inode *, struct kstat *);
    2307             : extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
    2308             : void __inode_add_bytes(struct inode *inode, loff_t bytes);
    2309             : void inode_add_bytes(struct inode *inode, loff_t bytes);
    2310             : void inode_sub_bytes(struct inode *inode, loff_t bytes);
    2311             : loff_t inode_get_bytes(struct inode *inode);
    2312             : void inode_set_bytes(struct inode *inode, loff_t bytes);
    2313             : 
    2314             : extern int vfs_readdir(struct file *, filldir_t, void *);
    2315             : 
    2316             : extern int vfs_stat(char __user *, struct kstat *);
    2317             : extern int vfs_lstat(char __user *, struct kstat *);
    2318             : extern int vfs_fstat(unsigned int, struct kstat *);
    2319             : extern int vfs_fstatat(int , char __user *, struct kstat *, int);
    2320             : 
    2321             : extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
    2322             :                     unsigned long arg);
    2323             : extern int __generic_block_fiemap(struct inode *inode,
    2324             :                                   struct fiemap_extent_info *fieinfo, u64 start,
    2325             :                                   u64 len, get_block_t *get_block);
    2326             : extern int generic_block_fiemap(struct inode *inode,
    2327             :                                 struct fiemap_extent_info *fieinfo, u64 start,
    2328             :                                 u64 len, get_block_t *get_block);
    2329             : 
    2330             : extern void get_filesystem(struct file_system_type *fs);
    2331             : extern void put_filesystem(struct file_system_type *fs);
    2332             : extern struct file_system_type *get_fs_type(const char *name);
    2333             : extern struct super_block *get_super(struct block_device *);
    2334             : extern struct super_block *get_active_super(struct block_device *bdev);
    2335             : extern struct super_block *user_get_super(dev_t);
    2336             : extern void drop_super(struct super_block *sb);
    2337             : 
    2338             : extern int dcache_dir_open(struct inode *, struct file *);
    2339             : extern int dcache_dir_close(struct inode *, struct file *);
    2340             : extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
    2341             : extern int dcache_readdir(struct file *, void *, filldir_t);
    2342             : extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
    2343             : extern int simple_statfs(struct dentry *, struct kstatfs *);
    2344             : extern int simple_link(struct dentry *, struct inode *, struct dentry *);
    2345             : extern int simple_unlink(struct inode *, struct dentry *);
    2346             : extern int simple_rmdir(struct inode *, struct dentry *);
    2347             : extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
    2348             : extern int simple_sync_file(struct file *, struct dentry *, int);
    2349             : extern int simple_empty(struct dentry *);
    2350             : extern int simple_readpage(struct file *file, struct page *page);
    2351             : extern int simple_prepare_write(struct file *file, struct page *page,
    2352             :                         unsigned offset, unsigned to);
    2353             : extern int simple_write_begin(struct file *file, struct address_space *mapping,
    2354             :                         loff_t pos, unsigned len, unsigned flags,
    2355             :                         struct page **pagep, void **fsdata);
    2356             : extern int simple_write_end(struct file *file, struct address_space *mapping,
    2357             :                         loff_t pos, unsigned len, unsigned copied,
    2358             :                         struct page *page, void *fsdata);
    2359             : 
    2360             : extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
    2361             : extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
    2362             : extern const struct file_operations simple_dir_operations;
    2363             : extern const struct inode_operations simple_dir_inode_operations;
    2364             : struct tree_descr { char *name; const struct file_operations *ops; int mode; };
    2365             : struct dentry *d_alloc_name(struct dentry *, const char *);
    2366             : extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *);
    2367             : extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
    2368             : extern void simple_release_fs(struct vfsmount **mount, int *count);
    2369             : 
    2370             : extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
    2371             :                         loff_t *ppos, const void *from, size_t available);
    2372             : 
    2373             : extern int simple_fsync(struct file *, struct dentry *, int);
    2374             : 
    2375             : #ifdef CONFIG_MIGRATION
    2376             : extern int buffer_migrate_page(struct address_space *,
    2377             :                                 struct page *, struct page *);
    2378             : #else
    2379             : #define buffer_migrate_page NULL
    2380             : #endif
    2381             : 
    2382             : extern int inode_change_ok(const struct inode *, struct iattr *);
    2383             : extern int inode_newsize_ok(const struct inode *, loff_t offset);
    2384             : extern int __must_check inode_setattr(struct inode *, struct iattr *);
    2385             : 
    2386             : extern void file_update_time(struct file *file);
    2387             : 
    2388             : extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);
    2389             : extern void save_mount_options(struct super_block *sb, char *options);
    2390             : extern void replace_mount_options(struct super_block *sb, char *options);
    2391             : 
    2392             : static inline ino_t parent_ino(struct dentry *dentry)
    2393             : {
    2394             :         ino_t res;
    2395             : 
    2396             :         spin_lock(&dentry->d_lock);
    2397             :         res = dentry->d_parent->d_inode->i_ino;
    2398             :         spin_unlock(&dentry->d_lock);
    2399             :         return res;
    2400             : }
    2401             : 
    2402             : /* Transaction based IO helpers */
    2403             : 
    2404             : /*
    2405             :  * An argresp is stored in an allocated page and holds the
    2406             :  * size of the argument or response, along with its content
    2407             :  */
    2408             : struct simple_transaction_argresp {
    2409             :         ssize_t size;
    2410             :         char data[0];
    2411             : };
    2412             : 
    2413             : #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
    2414             : 
    2415             : char *simple_transaction_get(struct file *file, const char __user *buf,
    2416             :                                 size_t size);
    2417             : ssize_t simple_transaction_read(struct file *file, char __user *buf,
    2418             :                                 size_t size, loff_t *pos);
    2419             : int simple_transaction_release(struct inode *inode, struct file *file);
    2420             : 
    2421             : void simple_transaction_set(struct file *file, size_t n);
    2422             : 
    2423             : /*
    2424             :  * simple attribute files
    2425             :  *
    2426             :  * These attributes behave similar to those in sysfs:
    2427             :  *
    2428             :  * Writing to an attribute immediately sets a value, an open file can be
    2429             :  * written to multiple times.
    2430             :  *
    2431             :  * Reading from an attribute creates a buffer from the value that might get
    2432             :  * read with multiple read calls. When the attribute has been read
    2433             :  * completely, no further read calls are possible until the file is opened
    2434             :  * again.
    2435             :  *
    2436             :  * All attributes contain a text representation of a numeric value
    2437             :  * that are accessed with the get() and set() functions.
    2438             :  */
    2439             : #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)            \
    2440             : static int __fops ## _open(struct inode *inode, struct file *file)      \
    2441             : {                                                                       \
    2442             :         __simple_attr_check_format(__fmt, 0ull);                        \
    2443             :         return simple_attr_open(inode, file, __get, __set, __fmt);      \
    2444             : }                                                                       \
    2445             : static const struct file_operations __fops = {                          \
    2446             :         .owner   = THIS_MODULE,                                         \
    2447             :         .open    = __fops ## _open,                                     \
    2448             :         .release = simple_attr_release,                                 \
    2449             :         .read    = simple_attr_read,                                    \
    2450             :         .write   = simple_attr_write,                                   \
    2451             : };
    2452             : 
    2453             : static inline void __attribute__((format(printf, 1, 2)))
    2454             : __simple_attr_check_format(const char *fmt, ...)
    2455             : {
    2456             :         /* don't do anything, just let the compiler check the arguments; */
    2457             : }
    2458             : 
    2459             : int simple_attr_open(struct inode *inode, struct file *file,
    2460             :                      int (*get)(void *, u64 *), int (*set)(void *, u64),
    2461             :                      const char *fmt);
    2462             : int simple_attr_release(struct inode *inode, struct file *file);
    2463             : ssize_t simple_attr_read(struct file *file, char __user *buf,
    2464             :                          size_t len, loff_t *ppos);
    2465             : ssize_t simple_attr_write(struct file *file, const char __user *buf,
    2466             :                           size_t len, loff_t *ppos);
    2467             : 
    2468             : struct ctl_table;
    2469             : int proc_nr_files(struct ctl_table *table, int write,
    2470             :                   void __user *buffer, size_t *lenp, loff_t *ppos);
    2471             : 
    2472             : int __init get_filesystem_list(char *buf);
    2473             : 
    2474             : #define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
    2475             : #define OPEN_FMODE(flag) ((__force fmode_t)((flag + 1) & O_ACCMODE))
    2476             : 
    2477             : #endif /* __KERNEL__ */
    2478             : #endif /* _LINUX_FS_H */

Generated by: LCOV version 1.10