LCOV - code coverage report
Current view: top level - include/linux - fs.h (source / functions) Hit Total Coverage
Test: Real Lines: 151 206 73.3 %
Date: 2020-10-17 15:46:16 Functions: 0 24 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _LINUX_FS_H
       3                 :            : #define _LINUX_FS_H
       4                 :            : 
       5                 :            : #include <linux/linkage.h>
       6                 :            : #include <linux/wait_bit.h>
       7                 :            : #include <linux/kdev_t.h>
       8                 :            : #include <linux/dcache.h>
       9                 :            : #include <linux/path.h>
      10                 :            : #include <linux/stat.h>
      11                 :            : #include <linux/cache.h>
      12                 :            : #include <linux/list.h>
      13                 :            : #include <linux/list_lru.h>
      14                 :            : #include <linux/llist.h>
      15                 :            : #include <linux/radix-tree.h>
      16                 :            : #include <linux/xarray.h>
      17                 :            : #include <linux/rbtree.h>
      18                 :            : #include <linux/init.h>
      19                 :            : #include <linux/pid.h>
      20                 :            : #include <linux/bug.h>
      21                 :            : #include <linux/mutex.h>
      22                 :            : #include <linux/rwsem.h>
      23                 :            : #include <linux/mm_types.h>
      24                 :            : #include <linux/capability.h>
      25                 :            : #include <linux/semaphore.h>
      26                 :            : #include <linux/fcntl.h>
      27                 :            : #include <linux/fiemap.h>
      28                 :            : #include <linux/rculist_bl.h>
      29                 :            : #include <linux/atomic.h>
      30                 :            : #include <linux/shrinker.h>
      31                 :            : #include <linux/migrate_mode.h>
      32                 :            : #include <linux/uidgid.h>
      33                 :            : #include <linux/lockdep.h>
      34                 :            : #include <linux/percpu-rwsem.h>
      35                 :            : #include <linux/workqueue.h>
      36                 :            : #include <linux/delayed_call.h>
      37                 :            : #include <linux/uuid.h>
      38                 :            : #include <linux/errseq.h>
      39                 :            : #include <linux/ioprio.h>
      40                 :            : #include <linux/fs_types.h>
      41                 :            : #include <linux/build_bug.h>
      42                 :            : #include <linux/stddef.h>
      43                 :            : 
      44                 :            : #include <asm/byteorder.h>
      45                 :            : #include <uapi/linux/fs.h>
      46                 :            : 
      47                 :            : struct backing_dev_info;
      48                 :            : struct bdi_writeback;
      49                 :            : struct bio;
      50                 :            : struct export_operations;
      51                 :            : struct hd_geometry;
      52                 :            : struct iovec;
      53                 :            : struct kiocb;
      54                 :            : struct kobject;
      55                 :            : struct pipe_inode_info;
      56                 :            : struct poll_table_struct;
      57                 :            : struct kstatfs;
      58                 :            : struct vm_area_struct;
      59                 :            : struct vfsmount;
      60                 :            : struct cred;
      61                 :            : struct swap_info_struct;
      62                 :            : struct seq_file;
      63                 :            : struct workqueue_struct;
      64                 :            : struct iov_iter;
      65                 :            : struct fscrypt_info;
      66                 :            : struct fscrypt_operations;
      67                 :            : struct fsverity_info;
      68                 :            : struct fsverity_operations;
      69                 :            : struct fs_context;
      70                 :            : struct fs_parameter_description;
      71                 :            : 
      72                 :            : extern void __init inode_init(void);
      73                 :            : extern void __init inode_init_early(void);
      74                 :            : extern void __init files_init(void);
      75                 :            : extern void __init files_maxfiles_init(void);
      76                 :            : 
      77                 :            : extern struct files_stat_struct files_stat;
      78                 :            : extern unsigned long get_max_files(void);
      79                 :            : extern unsigned int sysctl_nr_open;
      80                 :            : extern struct inodes_stat_t inodes_stat;
      81                 :            : extern int leases_enable, lease_break_time;
      82                 :            : extern int sysctl_protected_symlinks;
      83                 :            : extern int sysctl_protected_hardlinks;
      84                 :            : extern int sysctl_protected_fifos;
      85                 :            : extern int sysctl_protected_regular;
      86                 :            : 
      87                 :            : typedef __kernel_rwf_t rwf_t;
      88                 :            : 
      89                 :            : struct buffer_head;
      90                 :            : typedef int (get_block_t)(struct inode *inode, sector_t iblock,
      91                 :            :                         struct buffer_head *bh_result, int create);
      92                 :            : typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
      93                 :            :                         ssize_t bytes, void *private);
      94                 :            : 
      95                 :            : #define MAY_EXEC                0x00000001
      96                 :            : #define MAY_WRITE               0x00000002
      97                 :            : #define MAY_READ                0x00000004
      98                 :            : #define MAY_APPEND              0x00000008
      99                 :            : #define MAY_ACCESS              0x00000010
     100                 :            : #define MAY_OPEN                0x00000020
     101                 :            : #define MAY_CHDIR               0x00000040
     102                 :            : /* called from RCU mode, don't block */
     103                 :            : #define MAY_NOT_BLOCK           0x00000080
     104                 :            : 
     105                 :            : /*
     106                 :            :  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
     107                 :            :  * to O_WRONLY and O_RDWR via the strange trick in do_dentry_open()
     108                 :            :  */
     109                 :            : 
     110                 :            : /* file is open for reading */
     111                 :            : #define FMODE_READ              ((__force fmode_t)0x1)
     112                 :            : /* file is open for writing */
     113                 :            : #define FMODE_WRITE             ((__force fmode_t)0x2)
     114                 :            : /* file is seekable */
     115                 :            : #define FMODE_LSEEK             ((__force fmode_t)0x4)
     116                 :            : /* file can be accessed using pread */
     117                 :            : #define FMODE_PREAD             ((__force fmode_t)0x8)
     118                 :            : /* file can be accessed using pwrite */
     119                 :            : #define FMODE_PWRITE            ((__force fmode_t)0x10)
     120                 :            : /* File is opened for execution with sys_execve / sys_uselib */
     121                 :            : #define FMODE_EXEC              ((__force fmode_t)0x20)
     122                 :            : /* File is opened with O_NDELAY (only set for block devices) */
     123                 :            : #define FMODE_NDELAY            ((__force fmode_t)0x40)
     124                 :            : /* File is opened with O_EXCL (only set for block devices) */
     125                 :            : #define FMODE_EXCL              ((__force fmode_t)0x80)
     126                 :            : /* File is opened using open(.., 3, ..) and is writeable only for ioctls
     127                 :            :    (specialy hack for floppy.c) */
     128                 :            : #define FMODE_WRITE_IOCTL       ((__force fmode_t)0x100)
     129                 :            : /* 32bit hashes as llseek() offset (for directories) */
     130                 :            : #define FMODE_32BITHASH         ((__force fmode_t)0x200)
     131                 :            : /* 64bit hashes as llseek() offset (for directories) */
     132                 :            : #define FMODE_64BITHASH         ((__force fmode_t)0x400)
     133                 :            : 
     134                 :            : /*
     135                 :            :  * Don't update ctime and mtime.
     136                 :            :  *
     137                 :            :  * Currently a special hack for the XFS open_by_handle ioctl, but we'll
     138                 :            :  * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
     139                 :            :  */
     140                 :            : #define FMODE_NOCMTIME          ((__force fmode_t)0x800)
     141                 :            : 
     142                 :            : /* Expect random access pattern */
     143                 :            : #define FMODE_RANDOM            ((__force fmode_t)0x1000)
     144                 :            : 
     145                 :            : /* File is huge (eg. /dev/kmem): treat loff_t as unsigned */
     146                 :            : #define FMODE_UNSIGNED_OFFSET   ((__force fmode_t)0x2000)
     147                 :            : 
     148                 :            : /* File is opened with O_PATH; almost nothing can be done with it */
     149                 :            : #define FMODE_PATH              ((__force fmode_t)0x4000)
     150                 :            : 
     151                 :            : /* File needs atomic accesses to f_pos */
     152                 :            : #define FMODE_ATOMIC_POS        ((__force fmode_t)0x8000)
     153                 :            : /* Write access to underlying fs */
     154                 :            : #define FMODE_WRITER            ((__force fmode_t)0x10000)
     155                 :            : /* Has read method(s) */
     156                 :            : #define FMODE_CAN_READ          ((__force fmode_t)0x20000)
     157                 :            : /* Has write method(s) */
     158                 :            : #define FMODE_CAN_WRITE         ((__force fmode_t)0x40000)
     159                 :            : 
     160                 :            : #define FMODE_OPENED            ((__force fmode_t)0x80000)
     161                 :            : #define FMODE_CREATED           ((__force fmode_t)0x100000)
     162                 :            : 
     163                 :            : /* File is stream-like */
     164                 :            : #define FMODE_STREAM            ((__force fmode_t)0x200000)
     165                 :            : 
     166                 :            : /* File was opened by fanotify and shouldn't generate fanotify events */
     167                 :            : #define FMODE_NONOTIFY          ((__force fmode_t)0x4000000)
     168                 :            : 
     169                 :            : /* File is capable of returning -EAGAIN if I/O will block */
     170                 :            : #define FMODE_NOWAIT            ((__force fmode_t)0x8000000)
     171                 :            : 
     172                 :            : /* File represents mount that needs unmounting */
     173                 :            : #define FMODE_NEED_UNMOUNT      ((__force fmode_t)0x10000000)
     174                 :            : 
     175                 :            : /* File does not contribute to nr_files count */
     176                 :            : #define FMODE_NOACCOUNT         ((__force fmode_t)0x20000000)
     177                 :            : 
     178                 :            : /*
     179                 :            :  * Flag for rw_copy_check_uvector and compat_rw_copy_check_uvector
     180                 :            :  * that indicates that they should check the contents of the iovec are
     181                 :            :  * valid, but not check the memory that the iovec elements
     182                 :            :  * points too.
     183                 :            :  */
     184                 :            : #define CHECK_IOVEC_ONLY -1
     185                 :            : 
     186                 :            : /*
     187                 :            :  * Attribute flags.  These should be or-ed together to figure out what
     188                 :            :  * has been changed!
     189                 :            :  */
     190                 :            : #define ATTR_MODE       (1 << 0)
     191                 :            : #define ATTR_UID        (1 << 1)
     192                 :            : #define ATTR_GID        (1 << 2)
     193                 :            : #define ATTR_SIZE       (1 << 3)
     194                 :            : #define ATTR_ATIME      (1 << 4)
     195                 :            : #define ATTR_MTIME      (1 << 5)
     196                 :            : #define ATTR_CTIME      (1 << 6)
     197                 :            : #define ATTR_ATIME_SET  (1 << 7)
     198                 :            : #define ATTR_MTIME_SET  (1 << 8)
     199                 :            : #define ATTR_FORCE      (1 << 9) /* Not a change, but a change it */
     200                 :            : #define ATTR_KILL_SUID  (1 << 11)
     201                 :            : #define ATTR_KILL_SGID  (1 << 12)
     202                 :            : #define ATTR_FILE       (1 << 13)
     203                 :            : #define ATTR_KILL_PRIV  (1 << 14)
     204                 :            : #define ATTR_OPEN       (1 << 15) /* Truncating from open(O_TRUNC) */
     205                 :            : #define ATTR_TIMES_SET  (1 << 16)
     206                 :            : #define ATTR_TOUCH      (1 << 17)
     207                 :            : 
     208                 :            : /*
     209                 :            :  * Whiteout is represented by a char device.  The following constants define the
     210                 :            :  * mode and device number to use.
     211                 :            :  */
     212                 :            : #define WHITEOUT_MODE 0
     213                 :            : #define WHITEOUT_DEV 0
     214                 :            : 
     215                 :            : /*
     216                 :            :  * This is the Inode Attributes structure, used for notify_change().  It
     217                 :            :  * uses the above definitions as flags, to know which values have changed.
     218                 :            :  * Also, in this manner, a Filesystem can look at only the values it cares
     219                 :            :  * about.  Basically, these are the attributes that the VFS layer can
     220                 :            :  * request to change from the FS layer.
     221                 :            :  *
     222                 :            :  * Derek Atkins <warlord@MIT.EDU> 94-10-20
     223                 :            :  */
     224                 :            : struct iattr {
     225                 :            :         unsigned int    ia_valid;
     226                 :            :         umode_t         ia_mode;
     227                 :            :         kuid_t          ia_uid;
     228                 :            :         kgid_t          ia_gid;
     229                 :            :         loff_t          ia_size;
     230                 :            :         struct timespec64 ia_atime;
     231                 :            :         struct timespec64 ia_mtime;
     232                 :            :         struct timespec64 ia_ctime;
     233                 :            : 
     234                 :            :         /*
     235                 :            :          * Not an attribute, but an auxiliary info for filesystems wanting to
     236                 :            :          * implement an ftruncate() like method.  NOTE: filesystem should
     237                 :            :          * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
     238                 :            :          */
     239                 :            :         struct file     *ia_file;
     240                 :            : };
     241                 :            : 
     242                 :            : /*
     243                 :            :  * Includes for diskquotas.
     244                 :            :  */
     245                 :            : #include <linux/quota.h>
     246                 :            : 
     247                 :            : /*
     248                 :            :  * Maximum number of layers of fs stack.  Needs to be limited to
     249                 :            :  * prevent kernel stack overflow
     250                 :            :  */
     251                 :            : #define FILESYSTEM_MAX_STACK_DEPTH 2
     252                 :            : 
     253                 :            : /** 
     254                 :            :  * enum positive_aop_returns - aop return codes with specific semantics
     255                 :            :  *
     256                 :            :  * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
     257                 :            :  *                          completed, that the page is still locked, and
     258                 :            :  *                          should be considered active.  The VM uses this hint
     259                 :            :  *                          to return the page to the active list -- it won't
     260                 :            :  *                          be a candidate for writeback again in the near
     261                 :            :  *                          future.  Other callers must be careful to unlock
     262                 :            :  *                          the page if they get this return.  Returned by
     263                 :            :  *                          writepage(); 
     264                 :            :  *
     265                 :            :  * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
     266                 :            :  *                      unlocked it and the page might have been truncated.
     267                 :            :  *                      The caller should back up to acquiring a new page and
     268                 :            :  *                      trying again.  The aop will be taking reasonable
     269                 :            :  *                      precautions not to livelock.  If the caller held a page
     270                 :            :  *                      reference, it should drop it before retrying.  Returned
     271                 :            :  *                      by readpage().
     272                 :            :  *
     273                 :            :  * address_space_operation functions return these large constants to indicate
     274                 :            :  * special semantics to the caller.  These are much larger than the bytes in a
     275                 :            :  * page to allow for functions that return the number of bytes operated on in a
     276                 :            :  * given page.
     277                 :            :  */
     278                 :            : 
     279                 :            : enum positive_aop_returns {
     280                 :            :         AOP_WRITEPAGE_ACTIVATE  = 0x80000,
     281                 :            :         AOP_TRUNCATED_PAGE      = 0x80001,
     282                 :            : };
     283                 :            : 
     284                 :            : #define AOP_FLAG_CONT_EXPAND            0x0001 /* called from cont_expand */
     285                 :            : #define AOP_FLAG_NOFS                   0x0002 /* used by filesystem to direct
     286                 :            :                                                 * helper code (eg buffer layer)
     287                 :            :                                                 * to clear GFP_FS from alloc */
     288                 :            : 
     289                 :            : /*
     290                 :            :  * oh the beauties of C type declarations.
     291                 :            :  */
     292                 :            : struct page;
     293                 :            : struct address_space;
     294                 :            : struct writeback_control;
     295                 :            : 
     296                 :            : /*
     297                 :            :  * Write life time hint values.
     298                 :            :  * Stored in struct inode as u8.
     299                 :            :  */
     300                 :            : enum rw_hint {
     301                 :            :         WRITE_LIFE_NOT_SET      = 0,
     302                 :            :         WRITE_LIFE_NONE         = RWH_WRITE_LIFE_NONE,
     303                 :            :         WRITE_LIFE_SHORT        = RWH_WRITE_LIFE_SHORT,
     304                 :            :         WRITE_LIFE_MEDIUM       = RWH_WRITE_LIFE_MEDIUM,
     305                 :            :         WRITE_LIFE_LONG         = RWH_WRITE_LIFE_LONG,
     306                 :            :         WRITE_LIFE_EXTREME      = RWH_WRITE_LIFE_EXTREME,
     307                 :            : };
     308                 :            : 
     309                 :            : #define IOCB_EVENTFD            (1 << 0)
     310                 :            : #define IOCB_APPEND             (1 << 1)
     311                 :            : #define IOCB_DIRECT             (1 << 2)
     312                 :            : #define IOCB_HIPRI              (1 << 3)
     313                 :            : #define IOCB_DSYNC              (1 << 4)
     314                 :            : #define IOCB_SYNC               (1 << 5)
     315                 :            : #define IOCB_WRITE              (1 << 6)
     316                 :            : #define IOCB_NOWAIT             (1 << 7)
     317                 :            : 
     318                 :            : struct kiocb {
     319                 :            :         struct file             *ki_filp;
     320                 :            : 
     321                 :            :         /* The 'ki_filp' pointer is shared in a union for aio */
     322                 :            :         randomized_struct_fields_start
     323                 :            : 
     324                 :            :         loff_t                  ki_pos;
     325                 :            :         void (*ki_complete)(struct kiocb *iocb, long ret, long ret2);
     326                 :            :         void                    *private;
     327                 :            :         int                     ki_flags;
     328                 :            :         u16                     ki_hint;
     329                 :            :         u16                     ki_ioprio; /* See linux/ioprio.h */
     330                 :            :         unsigned int            ki_cookie; /* for ->iopoll */
     331                 :            : 
     332                 :            :         randomized_struct_fields_end
     333                 :            : };
     334                 :            : 
     335                 :            : static inline bool is_sync_kiocb(struct kiocb *kiocb)
     336                 :            : {
     337                 :          0 :         return kiocb->ki_complete == NULL;
     338                 :            : }
     339                 :            : 
     340                 :            : /*
     341                 :            :  * "descriptor" for what we're up to with a read.
     342                 :            :  * This allows us to use the same read code yet
     343                 :            :  * have multiple different users of the data that
     344                 :            :  * we read from a file.
     345                 :            :  *
     346                 :            :  * The simplest case just copies the data to user
     347                 :            :  * mode.
     348                 :            :  */
     349                 :            : typedef struct {
     350                 :            :         size_t written;
     351                 :            :         size_t count;
     352                 :            :         union {
     353                 :            :                 char __user *buf;
     354                 :            :                 void *data;
     355                 :            :         } arg;
     356                 :            :         int error;
     357                 :            : } read_descriptor_t;
     358                 :            : 
     359                 :            : typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
     360                 :            :                 unsigned long, unsigned long);
     361                 :            : 
     362                 :            : struct address_space_operations {
     363                 :            :         int (*writepage)(struct page *page, struct writeback_control *wbc);
     364                 :            :         int (*readpage)(struct file *, struct page *);
     365                 :            : 
     366                 :            :         /* Write back some dirty pages from this mapping. */
     367                 :            :         int (*writepages)(struct address_space *, struct writeback_control *);
     368                 :            : 
     369                 :            :         /* Set a page dirty.  Return true if this dirtied it */
     370                 :            :         int (*set_page_dirty)(struct page *page);
     371                 :            : 
     372                 :            :         /*
     373                 :            :          * Reads in the requested pages. Unlike ->readpage(), this is
     374                 :            :          * PURELY used for read-ahead!.
     375                 :            :          */
     376                 :            :         int (*readpages)(struct file *filp, struct address_space *mapping,
     377                 :            :                         struct list_head *pages, unsigned nr_pages);
     378                 :            : 
     379                 :            :         int (*write_begin)(struct file *, struct address_space *mapping,
     380                 :            :                                 loff_t pos, unsigned len, unsigned flags,
     381                 :            :                                 struct page **pagep, void **fsdata);
     382                 :            :         int (*write_end)(struct file *, struct address_space *mapping,
     383                 :            :                                 loff_t pos, unsigned len, unsigned copied,
     384                 :            :                                 struct page *page, void *fsdata);
     385                 :            : 
     386                 :            :         /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
     387                 :            :         sector_t (*bmap)(struct address_space *, sector_t);
     388                 :            :         void (*invalidatepage) (struct page *, unsigned int, unsigned int);
     389                 :            :         int (*releasepage) (struct page *, gfp_t);
     390                 :            :         void (*freepage)(struct page *);
     391                 :            :         ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
     392                 :            :         /*
     393                 :            :          * migrate the contents of a page to the specified target. If
     394                 :            :          * migrate_mode is MIGRATE_ASYNC, it must not block.
     395                 :            :          */
     396                 :            :         int (*migratepage) (struct address_space *,
     397                 :            :                         struct page *, struct page *, enum migrate_mode);
     398                 :            :         bool (*isolate_page)(struct page *, isolate_mode_t);
     399                 :            :         void (*putback_page)(struct page *);
     400                 :            :         int (*launder_page) (struct page *);
     401                 :            :         int (*is_partially_uptodate) (struct page *, unsigned long,
     402                 :            :                                         unsigned long);
     403                 :            :         void (*is_dirty_writeback) (struct page *, bool *, bool *);
     404                 :            :         int (*error_remove_page)(struct address_space *, struct page *);
     405                 :            : 
     406                 :            :         /* swapfile support */
     407                 :            :         int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
     408                 :            :                                 sector_t *span);
     409                 :            :         void (*swap_deactivate)(struct file *file);
     410                 :            : };
     411                 :            : 
     412                 :            : extern const struct address_space_operations empty_aops;
     413                 :            : 
     414                 :            : /*
     415                 :            :  * pagecache_write_begin/pagecache_write_end must be used by general code
     416                 :            :  * to write into the pagecache.
     417                 :            :  */
     418                 :            : int pagecache_write_begin(struct file *, struct address_space *mapping,
     419                 :            :                                 loff_t pos, unsigned len, unsigned flags,
     420                 :            :                                 struct page **pagep, void **fsdata);
     421                 :            : 
     422                 :            : int pagecache_write_end(struct file *, struct address_space *mapping,
     423                 :            :                                 loff_t pos, unsigned len, unsigned copied,
     424                 :            :                                 struct page *page, void *fsdata);
     425                 :            : 
     426                 :            : /**
     427                 :            :  * struct address_space - Contents of a cacheable, mappable object.
     428                 :            :  * @host: Owner, either the inode or the block_device.
     429                 :            :  * @i_pages: Cached pages.
     430                 :            :  * @gfp_mask: Memory allocation flags to use for allocating pages.
     431                 :            :  * @i_mmap_writable: Number of VM_SHARED mappings.
     432                 :            :  * @nr_thps: Number of THPs in the pagecache (non-shmem only).
     433                 :            :  * @i_mmap: Tree of private and shared mappings.
     434                 :            :  * @i_mmap_rwsem: Protects @i_mmap and @i_mmap_writable.
     435                 :            :  * @nrpages: Number of page entries, protected by the i_pages lock.
     436                 :            :  * @nrexceptional: Shadow or DAX entries, protected by the i_pages lock.
     437                 :            :  * @writeback_index: Writeback starts here.
     438                 :            :  * @a_ops: Methods.
     439                 :            :  * @flags: Error bits and flags (AS_*).
     440                 :            :  * @wb_err: The most recent error which has occurred.
     441                 :            :  * @private_lock: For use by the owner of the address_space.
     442                 :            :  * @private_list: For use by the owner of the address_space.
     443                 :            :  * @private_data: For use by the owner of the address_space.
     444                 :            :  */
     445                 :            : struct address_space {
     446                 :            :         struct inode            *host;
     447                 :            :         struct xarray           i_pages;
     448                 :            :         gfp_t                   gfp_mask;
     449                 :            :         atomic_t                i_mmap_writable;
     450                 :            : #ifdef CONFIG_READ_ONLY_THP_FOR_FS
     451                 :            :         /* number of thp, only for non-shmem files */
     452                 :            :         atomic_t                nr_thps;
     453                 :            : #endif
     454                 :            :         struct rb_root_cached   i_mmap;
     455                 :            :         struct rw_semaphore     i_mmap_rwsem;
     456                 :            :         unsigned long           nrpages;
     457                 :            :         unsigned long           nrexceptional;
     458                 :            :         pgoff_t                 writeback_index;
     459                 :            :         const struct address_space_operations *a_ops;
     460                 :            :         unsigned long           flags;
     461                 :            :         errseq_t                wb_err;
     462                 :            :         spinlock_t              private_lock;
     463                 :            :         struct list_head        private_list;
     464                 :            :         void                    *private_data;
     465                 :            : } __attribute__((aligned(sizeof(long)))) __randomize_layout;
     466                 :            :         /*
     467                 :            :          * On most architectures that alignment is already the case; but
     468                 :            :          * must be enforced here for CRIS, to let the least significant bit
     469                 :            :          * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
     470                 :            :          */
     471                 :            : struct request_queue;
     472                 :            : 
     473                 :            : struct block_device {
     474                 :            :         dev_t                   bd_dev;  /* not a kdev_t - it's a search key */
     475                 :            :         int                     bd_openers;
     476                 :            :         struct inode *          bd_inode;       /* will die */
     477                 :            :         struct super_block *    bd_super;
     478                 :            :         struct mutex            bd_mutex;       /* open/close mutex */
     479                 :            :         void *                  bd_claiming;
     480                 :            :         void *                  bd_holder;
     481                 :            :         int                     bd_holders;
     482                 :            :         bool                    bd_write_holder;
     483                 :            : #ifdef CONFIG_SYSFS
     484                 :            :         struct list_head        bd_holder_disks;
     485                 :            : #endif
     486                 :            :         struct block_device *   bd_contains;
     487                 :            :         unsigned                bd_block_size;
     488                 :            :         u8                      bd_partno;
     489                 :            :         struct hd_struct *      bd_part;
     490                 :            :         /* number of times partitions within this device have been opened. */
     491                 :            :         unsigned                bd_part_count;
     492                 :            :         int                     bd_invalidated;
     493                 :            :         struct gendisk *        bd_disk;
     494                 :            :         struct request_queue *  bd_queue;
     495                 :            :         struct backing_dev_info *bd_bdi;
     496                 :            :         struct list_head        bd_list;
     497                 :            :         /*
     498                 :            :          * Private data.  You must have bd_claim'ed the block_device
     499                 :            :          * to use this.  NOTE:  bd_claim allows an owner to claim
     500                 :            :          * the same device multiple times, the owner must take special
     501                 :            :          * care to not mess up bd_private for that case.
     502                 :            :          */
     503                 :            :         unsigned long           bd_private;
     504                 :            : 
     505                 :            :         /* The counter of freeze processes */
     506                 :            :         int                     bd_fsfreeze_count;
     507                 :            :         /* Mutex for freeze */
     508                 :            :         struct mutex            bd_fsfreeze_mutex;
     509                 :            : } __randomize_layout;
     510                 :            : 
     511                 :            : /* XArray tags, for tagging dirty and writeback pages in the pagecache. */
     512                 :            : #define PAGECACHE_TAG_DIRTY     XA_MARK_0
     513                 :            : #define PAGECACHE_TAG_WRITEBACK XA_MARK_1
     514                 :            : #define PAGECACHE_TAG_TOWRITE   XA_MARK_2
     515                 :            : 
     516                 :            : /*
     517                 :            :  * Returns true if any of the pages in the mapping are marked with the tag.
     518                 :            :  */
     519                 :            : static inline bool mapping_tagged(struct address_space *mapping, xa_mark_t tag)
     520                 :            : {
     521                 :            :         return xa_marked(&mapping->i_pages, tag);
     522                 :            : }
     523                 :            : 
     524                 :            : static inline void i_mmap_lock_write(struct address_space *mapping)
     525                 :            : {
     526                 :          3 :         down_write(&mapping->i_mmap_rwsem);
     527                 :            : }
     528                 :            : 
     529                 :            : static inline void i_mmap_unlock_write(struct address_space *mapping)
     530                 :            : {
     531                 :          3 :         up_write(&mapping->i_mmap_rwsem);
     532                 :            : }
     533                 :            : 
     534                 :            : static inline void i_mmap_lock_read(struct address_space *mapping)
     535                 :            : {
     536                 :          2 :         down_read(&mapping->i_mmap_rwsem);
     537                 :            : }
     538                 :            : 
     539                 :            : static inline void i_mmap_unlock_read(struct address_space *mapping)
     540                 :            : {
     541                 :          2 :         up_read(&mapping->i_mmap_rwsem);
     542                 :            : }
     543                 :            : 
     544                 :            : /*
     545                 :            :  * Might pages of this file be mapped into userspace?
     546                 :            :  */
     547                 :            : static inline int mapping_mapped(struct address_space *mapping)
     548                 :            : {
     549                 :          0 :         return  !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root);
     550                 :            : }
     551                 :            : 
     552                 :            : /*
     553                 :            :  * Might pages of this file have been modified in userspace?
     554                 :            :  * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
     555                 :            :  * marks vma as VM_SHARED if it is shared, and the file was opened for
     556                 :            :  * writing i.e. vma may be mprotected writable even if now readonly.
     557                 :            :  *
     558                 :            :  * If i_mmap_writable is negative, no new writable mappings are allowed. You
     559                 :            :  * can only deny writable mappings, if none exists right now.
     560                 :            :  */
     561                 :            : static inline int mapping_writably_mapped(struct address_space *mapping)
     562                 :            : {
     563                 :          3 :         return atomic_read(&mapping->i_mmap_writable) > 0;
     564                 :            : }
     565                 :            : 
     566                 :            : static inline int mapping_map_writable(struct address_space *mapping)
     567                 :            : {
     568                 :          3 :         return atomic_inc_unless_negative(&mapping->i_mmap_writable) ?
     569                 :          3 :                 0 : -EPERM;
     570                 :            : }
     571                 :            : 
     572                 :            : static inline void mapping_unmap_writable(struct address_space *mapping)
     573                 :            : {
     574                 :          3 :         atomic_dec(&mapping->i_mmap_writable);
     575                 :            : }
     576                 :            : 
     577                 :            : static inline int mapping_deny_writable(struct address_space *mapping)
     578                 :            : {
     579                 :          0 :         return atomic_dec_unless_positive(&mapping->i_mmap_writable) ?
     580                 :          0 :                 0 : -EBUSY;
     581                 :            : }
     582                 :            : 
     583                 :            : static inline void mapping_allow_writable(struct address_space *mapping)
     584                 :            : {
     585                 :          0 :         atomic_inc(&mapping->i_mmap_writable);
     586                 :            : }
     587                 :            : 
     588                 :            : /*
     589                 :            :  * Use sequence counter to get consistent i_size on 32-bit processors.
     590                 :            :  */
     591                 :            : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
     592                 :            : #include <linux/seqlock.h>
     593                 :            : #define __NEED_I_SIZE_ORDERED
     594                 :            : #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
     595                 :            : #else
     596                 :            : #define i_size_ordered_init(inode) do { } while (0)
     597                 :            : #endif
     598                 :            : 
     599                 :            : struct posix_acl;
     600                 :            : #define ACL_NOT_CACHED ((void *)(-1))
     601                 :            : #define ACL_DONT_CACHE ((void *)(-3))
     602                 :            : 
     603                 :            : static inline struct posix_acl *
     604                 :            : uncached_acl_sentinel(struct task_struct *task)
     605                 :            : {
     606                 :          3 :         return (void *)task + 1;
     607                 :            : }
     608                 :            : 
     609                 :            : static inline bool
     610                 :            : is_uncached_acl(struct posix_acl *acl)
     611                 :            : {
     612                 :          3 :         return (long)acl & 1;
     613                 :            : }
     614                 :            : 
     615                 :            : #define IOP_FASTPERM    0x0001
     616                 :            : #define IOP_LOOKUP      0x0002
     617                 :            : #define IOP_NOFOLLOW    0x0004
     618                 :            : #define IOP_XATTR       0x0008
     619                 :            : #define IOP_DEFAULT_READLINK    0x0010
     620                 :            : 
     621                 :            : struct fsnotify_mark_connector;
     622                 :            : 
     623                 :            : /*
     624                 :            :  * Keep mostly read-only and often accessed (especially for
     625                 :            :  * the RCU path lookup and 'stat' data) fields at the beginning
     626                 :            :  * of the 'struct inode'
     627                 :            :  */
     628                 :            : struct inode {
     629                 :            :         umode_t                 i_mode;
     630                 :            :         unsigned short          i_opflags;
     631                 :            :         kuid_t                  i_uid;
     632                 :            :         kgid_t                  i_gid;
     633                 :            :         unsigned int            i_flags;
     634                 :            : 
     635                 :            : #ifdef CONFIG_FS_POSIX_ACL
     636                 :            :         struct posix_acl        *i_acl;
     637                 :            :         struct posix_acl        *i_default_acl;
     638                 :            : #endif
     639                 :            : 
     640                 :            :         const struct inode_operations   *i_op;
     641                 :            :         struct super_block      *i_sb;
     642                 :            :         struct address_space    *i_mapping;
     643                 :            : 
     644                 :            : #ifdef CONFIG_SECURITY
     645                 :            :         void                    *i_security;
     646                 :            : #endif
     647                 :            : 
     648                 :            :         /* Stat data, not accessed from path walking */
     649                 :            :         unsigned long           i_ino;
     650                 :            :         /*
     651                 :            :          * Filesystems may only read i_nlink directly.  They shall use the
     652                 :            :          * following functions for modification:
     653                 :            :          *
     654                 :            :          *    (set|clear|inc|drop)_nlink
     655                 :            :          *    inode_(inc|dec)_link_count
     656                 :            :          */
     657                 :            :         union {
     658                 :            :                 const unsigned int i_nlink;
     659                 :            :                 unsigned int __i_nlink;
     660                 :            :         };
     661                 :            :         dev_t                   i_rdev;
     662                 :            :         loff_t                  i_size;
     663                 :            :         struct timespec64       i_atime;
     664                 :            :         struct timespec64       i_mtime;
     665                 :            :         struct timespec64       i_ctime;
     666                 :            :         spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
     667                 :            :         unsigned short          i_bytes;
     668                 :            :         u8                      i_blkbits;
     669                 :            :         u8                      i_write_hint;
     670                 :            :         blkcnt_t                i_blocks;
     671                 :            : 
     672                 :            : #ifdef __NEED_I_SIZE_ORDERED
     673                 :            :         seqcount_t              i_size_seqcount;
     674                 :            : #endif
     675                 :            : 
     676                 :            :         /* Misc */
     677                 :            :         unsigned long           i_state;
     678                 :            :         struct rw_semaphore     i_rwsem;
     679                 :            : 
     680                 :            :         unsigned long           dirtied_when;   /* jiffies of first dirtying */
     681                 :            :         unsigned long           dirtied_time_when;
     682                 :            : 
     683                 :            :         struct hlist_node       i_hash;
     684                 :            :         struct list_head        i_io_list;      /* backing dev IO list */
     685                 :            : #ifdef CONFIG_CGROUP_WRITEBACK
     686                 :            :         struct bdi_writeback    *i_wb;          /* the associated cgroup wb */
     687                 :            : 
     688                 :            :         /* foreign inode detection, see wbc_detach_inode() */
     689                 :            :         int                     i_wb_frn_winner;
     690                 :            :         u16                     i_wb_frn_avg_time;
     691                 :            :         u16                     i_wb_frn_history;
     692                 :            : #endif
     693                 :            :         struct list_head        i_lru;          /* inode LRU list */
     694                 :            :         struct list_head        i_sb_list;
     695                 :            :         struct list_head        i_wb_list;      /* backing dev writeback list */
     696                 :            :         union {
     697                 :            :                 struct hlist_head       i_dentry;
     698                 :            :                 struct rcu_head         i_rcu;
     699                 :            :         };
     700                 :            :         atomic64_t              i_version;
     701                 :            :         atomic64_t              i_sequence; /* see futex */
     702                 :            :         atomic_t                i_count;
     703                 :            :         atomic_t                i_dio_count;
     704                 :            :         atomic_t                i_writecount;
     705                 :            : #if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
     706                 :            :         atomic_t                i_readcount; /* struct files open RO */
     707                 :            : #endif
     708                 :            :         union {
     709                 :            :                 const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
     710                 :            :                 void (*free_inode)(struct inode *);
     711                 :            :         };
     712                 :            :         struct file_lock_context        *i_flctx;
     713                 :            :         struct address_space    i_data;
     714                 :            :         struct list_head        i_devices;
     715                 :            :         union {
     716                 :            :                 struct pipe_inode_info  *i_pipe;
     717                 :            :                 struct block_device     *i_bdev;
     718                 :            :                 struct cdev             *i_cdev;
     719                 :            :                 char                    *i_link;
     720                 :            :                 unsigned                i_dir_seq;
     721                 :            :         };
     722                 :            : 
     723                 :            :         __u32                   i_generation;
     724                 :            : 
     725                 :            : #ifdef CONFIG_FSNOTIFY
     726                 :            :         __u32                   i_fsnotify_mask; /* all events this inode cares about */
     727                 :            :         struct fsnotify_mark_connector __rcu    *i_fsnotify_marks;
     728                 :            : #endif
     729                 :            : 
     730                 :            : #ifdef CONFIG_FS_ENCRYPTION
     731                 :            :         struct fscrypt_info     *i_crypt_info;
     732                 :            : #endif
     733                 :            : 
     734                 :            : #ifdef CONFIG_FS_VERITY
     735                 :            :         struct fsverity_info    *i_verity_info;
     736                 :            : #endif
     737                 :            : 
     738                 :            :         void                    *i_private; /* fs or device private pointer */
     739                 :            : } __randomize_layout;
     740                 :            : 
     741                 :            : struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
     742                 :            : 
     743                 :            : static inline unsigned int i_blocksize(const struct inode *node)
     744                 :            : {
     745                 :          3 :         return (1 << node->i_blkbits);
     746                 :            : }
     747                 :            : 
     748                 :            : static inline int inode_unhashed(struct inode *inode)
     749                 :            : {
     750                 :            :         return hlist_unhashed(&inode->i_hash);
     751                 :            : }
     752                 :            : 
     753                 :            : /*
     754                 :            :  * __mark_inode_dirty expects inodes to be hashed.  Since we don't
     755                 :            :  * want special inodes in the fileset inode space, we make them
     756                 :            :  * appear hashed, but do not put on any lists.  hlist_del()
     757                 :            :  * will work fine and require no locking.
     758                 :            :  */
     759                 :            : static inline void inode_fake_hash(struct inode *inode)
     760                 :            : {
     761                 :            :         hlist_add_fake(&inode->i_hash);
     762                 :            : }
     763                 :            : 
     764                 :            : /*
     765                 :            :  * inode->i_mutex nesting subclasses for the lock validator:
     766                 :            :  *
     767                 :            :  * 0: the object of the current VFS operation
     768                 :            :  * 1: parent
     769                 :            :  * 2: child/target
     770                 :            :  * 3: xattr
     771                 :            :  * 4: second non-directory
     772                 :            :  * 5: second parent (when locking independent directories in rename)
     773                 :            :  *
     774                 :            :  * I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two
     775                 :            :  * non-directories at once.
     776                 :            :  *
     777                 :            :  * The locking order between these classes is
     778                 :            :  * parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory
     779                 :            :  */
     780                 :            : enum inode_i_mutex_lock_class
     781                 :            : {
     782                 :            :         I_MUTEX_NORMAL,
     783                 :            :         I_MUTEX_PARENT,
     784                 :            :         I_MUTEX_CHILD,
     785                 :            :         I_MUTEX_XATTR,
     786                 :            :         I_MUTEX_NONDIR2,
     787                 :            :         I_MUTEX_PARENT2,
     788                 :            : };
     789                 :            : 
     790                 :            : static inline void inode_lock(struct inode *inode)
     791                 :            : {
     792                 :          3 :         down_write(&inode->i_rwsem);
     793                 :            : }
     794                 :            : 
     795                 :            : static inline void inode_unlock(struct inode *inode)
     796                 :            : {
     797                 :          3 :         up_write(&inode->i_rwsem);
     798                 :            : }
     799                 :            : 
     800                 :            : static inline void inode_lock_shared(struct inode *inode)
     801                 :            : {
     802                 :          3 :         down_read(&inode->i_rwsem);
     803                 :            : }
     804                 :            : 
     805                 :            : static inline void inode_unlock_shared(struct inode *inode)
     806                 :            : {
     807                 :          3 :         up_read(&inode->i_rwsem);
     808                 :            : }
     809                 :            : 
     810                 :            : static inline int inode_trylock(struct inode *inode)
     811                 :            : {
     812                 :          3 :         return down_write_trylock(&inode->i_rwsem);
     813                 :            : }
     814                 :            : 
     815                 :            : static inline int inode_trylock_shared(struct inode *inode)
     816                 :            : {
     817                 :          0 :         return down_read_trylock(&inode->i_rwsem);
     818                 :            : }
     819                 :            : 
     820                 :            : static inline int inode_is_locked(struct inode *inode)
     821                 :            : {
     822                 :            :         return rwsem_is_locked(&inode->i_rwsem);
     823                 :            : }
     824                 :            : 
     825                 :            : static inline void inode_lock_nested(struct inode *inode, unsigned subclass)
     826                 :            : {
     827                 :          3 :         down_write_nested(&inode->i_rwsem, subclass);
     828                 :            : }
     829                 :            : 
     830                 :            : static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass)
     831                 :            : {
     832                 :            :         down_read_nested(&inode->i_rwsem, subclass);
     833                 :            : }
     834                 :            : 
     835                 :            : void lock_two_nondirectories(struct inode *, struct inode*);
     836                 :            : void unlock_two_nondirectories(struct inode *, struct inode*);
     837                 :            : 
     838                 :            : /*
     839                 :            :  * NOTE: in a 32bit arch with a preemptable kernel and
     840                 :            :  * an UP compile the i_size_read/write must be atomic
     841                 :            :  * with respect to the local cpu (unlike with preempt disabled),
     842                 :            :  * but they don't need to be atomic with respect to other cpus like in
     843                 :            :  * true SMP (so they need either to either locally disable irq around
     844                 :            :  * the read or for example on x86 they can be still implemented as a
     845                 :            :  * cmpxchg8b without the need of the lock prefix). For SMP compiles
     846                 :            :  * and 64bit archs it makes no difference if preempt is enabled or not.
     847                 :            :  */
     848                 :            : static inline loff_t i_size_read(const struct inode *inode)
     849                 :            : {
     850                 :            : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
     851                 :            :         loff_t i_size;
     852                 :            :         unsigned int seq;
     853                 :            : 
     854                 :            :         do {
     855                 :            :                 seq = read_seqcount_begin(&inode->i_size_seqcount);
     856                 :          3 :                 i_size = inode->i_size;
     857                 :          3 :         } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
     858                 :          3 :         return i_size;
     859                 :            : #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
     860                 :            :         loff_t i_size;
     861                 :            : 
     862                 :            :         preempt_disable();
     863                 :            :         i_size = inode->i_size;
     864                 :            :         preempt_enable();
     865                 :            :         return i_size;
     866                 :            : #else
     867                 :            :         return inode->i_size;
     868                 :            : #endif
     869                 :            : }
     870                 :            : 
     871                 :            : /*
     872                 :            :  * NOTE: unlike i_size_read(), i_size_write() does need locking around it
     873                 :            :  * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
     874                 :            :  * can be lost, resulting in subsequent i_size_read() calls spinning forever.
     875                 :            :  */
     876                 :            : static inline void i_size_write(struct inode *inode, loff_t i_size)
     877                 :            : {
     878                 :            : #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
     879                 :          3 :         preempt_disable();
     880                 :            :         write_seqcount_begin(&inode->i_size_seqcount);
     881                 :          3 :         inode->i_size = i_size;
     882                 :            :         write_seqcount_end(&inode->i_size_seqcount);
     883                 :          3 :         preempt_enable();
     884                 :            : #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
     885                 :            :         preempt_disable();
     886                 :            :         inode->i_size = i_size;
     887                 :            :         preempt_enable();
     888                 :            : #else
     889                 :            :         inode->i_size = i_size;
     890                 :            : #endif
     891                 :            : }
     892                 :            : 
     893                 :            : static inline unsigned iminor(const struct inode *inode)
     894                 :            : {
     895                 :          3 :         return MINOR(inode->i_rdev);
     896                 :            : }
     897                 :            : 
     898                 :            : static inline unsigned imajor(const struct inode *inode)
     899                 :            : {
     900                 :          3 :         return MAJOR(inode->i_rdev);
     901                 :            : }
     902                 :            : 
     903                 :            : extern struct block_device *I_BDEV(struct inode *inode);
     904                 :            : 
     905                 :            : struct fown_struct {
     906                 :            :         rwlock_t lock;          /* protects pid, uid, euid fields */
     907                 :            :         struct pid *pid;        /* pid or -pgrp where SIGIO should be sent */
     908                 :            :         enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
     909                 :            :         kuid_t uid, euid;       /* uid/euid of process setting the owner */
     910                 :            :         int signum;             /* posix.1b rt signal to be delivered on IO */
     911                 :            : };
     912                 :            : 
     913                 :            : /*
     914                 :            :  * Track a single file's readahead state
     915                 :            :  */
     916                 :            : struct file_ra_state {
     917                 :            :         pgoff_t start;                  /* where readahead started */
     918                 :            :         unsigned int size;              /* # of readahead pages */
     919                 :            :         unsigned int async_size;        /* do asynchronous readahead when
     920                 :            :                                            there are only # of pages ahead */
     921                 :            : 
     922                 :            :         unsigned int ra_pages;          /* Maximum readahead window */
     923                 :            :         unsigned int mmap_miss;         /* Cache miss stat for mmap accesses */
     924                 :            :         loff_t prev_pos;                /* Cache last read() position */
     925                 :            : };
     926                 :            : 
     927                 :            : /*
     928                 :            :  * Check if @index falls in the readahead windows.
     929                 :            :  */
     930                 :            : static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
     931                 :            : {
     932                 :          0 :         return (index >= ra->start &&
     933                 :          0 :                 index <  ra->start + ra->size);
     934                 :            : }
     935                 :            : 
     936                 :            : struct file {
     937                 :            :         union {
     938                 :            :                 struct llist_node       fu_llist;
     939                 :            :                 struct rcu_head         fu_rcuhead;
     940                 :            :         } f_u;
     941                 :            :         struct path             f_path;
     942                 :            :         struct inode            *f_inode;       /* cached value */
     943                 :            :         const struct file_operations    *f_op;
     944                 :            : 
     945                 :            :         /*
     946                 :            :          * Protects f_ep_links, f_flags.
     947                 :            :          * Must not be taken from IRQ context.
     948                 :            :          */
     949                 :            :         spinlock_t              f_lock;
     950                 :            :         enum rw_hint            f_write_hint;
     951                 :            :         atomic_long_t           f_count;
     952                 :            :         unsigned int            f_flags;
     953                 :            :         fmode_t                 f_mode;
     954                 :            :         struct mutex            f_pos_lock;
     955                 :            :         loff_t                  f_pos;
     956                 :            :         struct fown_struct      f_owner;
     957                 :            :         const struct cred       *f_cred;
     958                 :            :         struct file_ra_state    f_ra;
     959                 :            : 
     960                 :            :         u64                     f_version;
     961                 :            : #ifdef CONFIG_SECURITY
     962                 :            :         void                    *f_security;
     963                 :            : #endif
     964                 :            :         /* needed for tty driver, and maybe others */
     965                 :            :         void                    *private_data;
     966                 :            : 
     967                 :            : #ifdef CONFIG_EPOLL
     968                 :            :         /* Used by fs/eventpoll.c to link all the hooks to this file */
     969                 :            :         struct list_head        f_ep_links;
     970                 :            :         struct list_head        f_tfile_llink;
     971                 :            : #endif /* #ifdef CONFIG_EPOLL */
     972                 :            :         struct address_space    *f_mapping;
     973                 :            :         errseq_t                f_wb_err;
     974                 :            : } __randomize_layout
     975                 :            :   __attribute__((aligned(4)));  /* lest something weird decides that 2 is OK */
     976                 :            : 
     977                 :            : struct file_handle {
     978                 :            :         __u32 handle_bytes;
     979                 :            :         int handle_type;
     980                 :            :         /* file identifier */
     981                 :            :         unsigned char f_handle[];
     982                 :            : };
     983                 :            : 
     984                 :            : static inline struct file *get_file(struct file *f)
     985                 :            : {
     986                 :          3 :         atomic_long_inc(&f->f_count);
     987                 :            :         return f;
     988                 :            : }
     989                 :            : #define get_file_rcu_many(x, cnt)       \
     990                 :            :         atomic_long_add_unless(&(x)->f_count, (cnt), 0)
     991                 :            : #define get_file_rcu(x) get_file_rcu_many((x), 1)
     992                 :            : #define file_count(x)   atomic_long_read(&(x)->f_count)
     993                 :            : 
     994                 :            : #define MAX_NON_LFS     ((1UL<<31) - 1)
     995                 :            : 
     996                 :            : /* Page cache limit. The filesystems should put that into their s_maxbytes 
     997                 :            :    limits, otherwise bad things can happen in VM. */ 
     998                 :            : #if BITS_PER_LONG==32
     999                 :            : #define MAX_LFS_FILESIZE        ((loff_t)ULONG_MAX << PAGE_SHIFT)
    1000                 :            : #elif BITS_PER_LONG==64
    1001                 :            : #define MAX_LFS_FILESIZE        ((loff_t)LLONG_MAX)
    1002                 :            : #endif
    1003                 :            : 
    1004                 :            : #define FL_POSIX        1
    1005                 :            : #define FL_FLOCK        2
    1006                 :            : #define FL_DELEG        4       /* NFSv4 delegation */
    1007                 :            : #define FL_ACCESS       8       /* not trying to lock, just looking */
    1008                 :            : #define FL_EXISTS       16      /* when unlocking, test for existence */
    1009                 :            : #define FL_LEASE        32      /* lease held on this file */
    1010                 :            : #define FL_CLOSE        64      /* unlock on close */
    1011                 :            : #define FL_SLEEP        128     /* A blocking lock */
    1012                 :            : #define FL_DOWNGRADE_PENDING    256 /* Lease is being downgraded */
    1013                 :            : #define FL_UNLOCK_PENDING       512 /* Lease is being broken */
    1014                 :            : #define FL_OFDLCK       1024    /* lock is "owned" by struct file */
    1015                 :            : #define FL_LAYOUT       2048    /* outstanding pNFS layout */
    1016                 :            : 
    1017                 :            : #define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE)
    1018                 :            : 
    1019                 :            : /*
    1020                 :            :  * Special return value from posix_lock_file() and vfs_lock_file() for
    1021                 :            :  * asynchronous locking.
    1022                 :            :  */
    1023                 :            : #define FILE_LOCK_DEFERRED 1
    1024                 :            : 
    1025                 :            : /* legacy typedef, should eventually be removed */
    1026                 :            : typedef void *fl_owner_t;
    1027                 :            : 
    1028                 :            : struct file_lock;
    1029                 :            : 
    1030                 :            : struct file_lock_operations {
    1031                 :            :         void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
    1032                 :            :         void (*fl_release_private)(struct file_lock *);
    1033                 :            : };
    1034                 :            : 
    1035                 :            : struct lock_manager_operations {
    1036                 :            :         fl_owner_t (*lm_get_owner)(fl_owner_t);
    1037                 :            :         void (*lm_put_owner)(fl_owner_t);
    1038                 :            :         void (*lm_notify)(struct file_lock *);  /* unblock callback */
    1039                 :            :         int (*lm_grant)(struct file_lock *, int);
    1040                 :            :         bool (*lm_break)(struct file_lock *);
    1041                 :            :         int (*lm_change)(struct file_lock *, int, struct list_head *);
    1042                 :            :         void (*lm_setup)(struct file_lock *, void **);
    1043                 :            : };
    1044                 :            : 
    1045                 :            : struct lock_manager {
    1046                 :            :         struct list_head list;
    1047                 :            :         /*
    1048                 :            :          * NFSv4 and up also want opens blocked during the grace period;
    1049                 :            :          * NLM doesn't care:
    1050                 :            :          */
    1051                 :            :         bool block_opens;
    1052                 :            : };
    1053                 :            : 
    1054                 :            : struct net;
    1055                 :            : void locks_start_grace(struct net *, struct lock_manager *);
    1056                 :            : void locks_end_grace(struct lock_manager *);
    1057                 :            : bool locks_in_grace(struct net *);
    1058                 :            : bool opens_in_grace(struct net *);
    1059                 :            : 
    1060                 :            : /* that will die - we need it for nfs_lock_info */
    1061                 :            : #include <linux/nfs_fs_i.h>
    1062                 :            : 
    1063                 :            : /*
    1064                 :            :  * struct file_lock represents a generic "file lock". It's used to represent
    1065                 :            :  * POSIX byte range locks, BSD (flock) locks, and leases. It's important to
    1066                 :            :  * note that the same struct is used to represent both a request for a lock and
    1067                 :            :  * the lock itself, but the same object is never used for both.
    1068                 :            :  *
    1069                 :            :  * FIXME: should we create a separate "struct lock_request" to help distinguish
    1070                 :            :  * these two uses?
    1071                 :            :  *
    1072                 :            :  * The varous i_flctx lists are ordered by:
    1073                 :            :  *
    1074                 :            :  * 1) lock owner
    1075                 :            :  * 2) lock range start
    1076                 :            :  * 3) lock range end
    1077                 :            :  *
    1078                 :            :  * Obviously, the last two criteria only matter for POSIX locks.
    1079                 :            :  */
    1080                 :            : struct file_lock {
    1081                 :            :         struct file_lock *fl_blocker;   /* The lock, that is blocking us */
    1082                 :            :         struct list_head fl_list;       /* link into file_lock_context */
    1083                 :            :         struct hlist_node fl_link;      /* node in global lists */
    1084                 :            :         struct list_head fl_blocked_requests;   /* list of requests with
    1085                 :            :                                                  * ->fl_blocker pointing here
    1086                 :            :                                                  */
    1087                 :            :         struct list_head fl_blocked_member;     /* node in
    1088                 :            :                                                  * ->fl_blocker->fl_blocked_requests
    1089                 :            :                                                  */
    1090                 :            :         fl_owner_t fl_owner;
    1091                 :            :         unsigned int fl_flags;
    1092                 :            :         unsigned char fl_type;
    1093                 :            :         unsigned int fl_pid;
    1094                 :            :         int fl_link_cpu;                /* what cpu's list is this on? */
    1095                 :            :         wait_queue_head_t fl_wait;
    1096                 :            :         struct file *fl_file;
    1097                 :            :         loff_t fl_start;
    1098                 :            :         loff_t fl_end;
    1099                 :            : 
    1100                 :            :         struct fasync_struct *  fl_fasync; /* for lease break notifications */
    1101                 :            :         /* for lease breaks: */
    1102                 :            :         unsigned long fl_break_time;
    1103                 :            :         unsigned long fl_downgrade_time;
    1104                 :            : 
    1105                 :            :         const struct file_lock_operations *fl_ops;      /* Callbacks for filesystems */
    1106                 :            :         const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */
    1107                 :            :         union {
    1108                 :            :                 struct nfs_lock_info    nfs_fl;
    1109                 :            :                 struct nfs4_lock_info   nfs4_fl;
    1110                 :            :                 struct {
    1111                 :            :                         struct list_head link;  /* link in AFS vnode's pending_locks list */
    1112                 :            :                         int state;              /* state of grant or error if -ve */
    1113                 :            :                         unsigned int    debug_id;
    1114                 :            :                 } afs;
    1115                 :            :         } fl_u;
    1116                 :            : } __randomize_layout;
    1117                 :            : 
    1118                 :            : struct file_lock_context {
    1119                 :            :         spinlock_t              flc_lock;
    1120                 :            :         struct list_head        flc_flock;
    1121                 :            :         struct list_head        flc_posix;
    1122                 :            :         struct list_head        flc_lease;
    1123                 :            : };
    1124                 :            : 
    1125                 :            : /* The following constant reflects the upper bound of the file/locking space */
    1126                 :            : #ifndef OFFSET_MAX
    1127                 :            : #define INT_LIMIT(x)    (~((x)1 << (sizeof(x)*8 - 1)))
    1128                 :            : #define OFFSET_MAX      INT_LIMIT(loff_t)
    1129                 :            : #define OFFT_OFFSET_MAX INT_LIMIT(off_t)
    1130                 :            : #endif
    1131                 :            : 
    1132                 :            : extern void send_sigio(struct fown_struct *fown, int fd, int band);
    1133                 :            : 
    1134                 :            : #define locks_inode(f) file_inode(f)
    1135                 :            : 
    1136                 :            : #ifdef CONFIG_FILE_LOCKING
    1137                 :            : extern int fcntl_getlk(struct file *, unsigned int, struct flock *);
    1138                 :            : extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
    1139                 :            :                         struct flock *);
    1140                 :            : 
    1141                 :            : #if BITS_PER_LONG == 32
    1142                 :            : extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);
    1143                 :            : extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
    1144                 :            :                         struct flock64 *);
    1145                 :            : #endif
    1146                 :            : 
    1147                 :            : extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
    1148                 :            : extern int fcntl_getlease(struct file *filp);
    1149                 :            : 
    1150                 :            : /* fs/locks.c */
    1151                 :            : void locks_free_lock_context(struct inode *inode);
    1152                 :            : void locks_free_lock(struct file_lock *fl);
    1153                 :            : extern void locks_init_lock(struct file_lock *);
    1154                 :            : extern struct file_lock * locks_alloc_lock(void);
    1155                 :            : extern void locks_copy_lock(struct file_lock *, struct file_lock *);
    1156                 :            : extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
    1157                 :            : extern void locks_remove_posix(struct file *, fl_owner_t);
    1158                 :            : extern void locks_remove_file(struct file *);
    1159                 :            : extern void locks_release_private(struct file_lock *);
    1160                 :            : extern void posix_test_lock(struct file *, struct file_lock *);
    1161                 :            : extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
    1162                 :            : extern int locks_delete_block(struct file_lock *);
    1163                 :            : extern int vfs_test_lock(struct file *, struct file_lock *);
    1164                 :            : extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
    1165                 :            : extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
    1166                 :            : extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
    1167                 :            : extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
    1168                 :            : extern void lease_get_mtime(struct inode *, struct timespec64 *time);
    1169                 :            : extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
    1170                 :            : extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
    1171                 :            : extern int lease_modify(struct file_lock *, int, struct list_head *);
    1172                 :            : 
    1173                 :            : struct notifier_block;
    1174                 :            : extern int lease_register_notifier(struct notifier_block *);
    1175                 :            : extern void lease_unregister_notifier(struct notifier_block *);
    1176                 :            : 
    1177                 :            : struct files_struct;
    1178                 :            : extern void show_fd_locks(struct seq_file *f,
    1179                 :            :                          struct file *filp, struct files_struct *files);
    1180                 :            : #else /* !CONFIG_FILE_LOCKING */
    1181                 :            : static inline int fcntl_getlk(struct file *file, unsigned int cmd,
    1182                 :            :                               struct flock __user *user)
    1183                 :            : {
    1184                 :            :         return -EINVAL;
    1185                 :            : }
    1186                 :            : 
    1187                 :            : static inline int fcntl_setlk(unsigned int fd, struct file *file,
    1188                 :            :                               unsigned int cmd, struct flock __user *user)
    1189                 :            : {
    1190                 :            :         return -EACCES;
    1191                 :            : }
    1192                 :            : 
    1193                 :            : #if BITS_PER_LONG == 32
    1194                 :            : static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
    1195                 :            :                                 struct flock64 __user *user)
    1196                 :            : {
    1197                 :            :         return -EINVAL;
    1198                 :            : }
    1199                 :            : 
    1200                 :            : static inline int fcntl_setlk64(unsigned int fd, struct file *file,
    1201                 :            :                                 unsigned int cmd, struct flock64 __user *user)
    1202                 :            : {
    1203                 :            :         return -EACCES;
    1204                 :            : }
    1205                 :            : #endif
    1206                 :            : static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
    1207                 :            : {
    1208                 :            :         return -EINVAL;
    1209                 :            : }
    1210                 :            : 
    1211                 :            : static inline int fcntl_getlease(struct file *filp)
    1212                 :            : {
    1213                 :            :         return F_UNLCK;
    1214                 :            : }
    1215                 :            : 
    1216                 :            : static inline void
    1217                 :            : locks_free_lock_context(struct inode *inode)
    1218                 :            : {
    1219                 :            : }
    1220                 :            : 
    1221                 :            : static inline void locks_init_lock(struct file_lock *fl)
    1222                 :            : {
    1223                 :            :         return;
    1224                 :            : }
    1225                 :            : 
    1226                 :            : static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
    1227                 :            : {
    1228                 :            :         return;
    1229                 :            : }
    1230                 :            : 
    1231                 :            : static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
    1232                 :            : {
    1233                 :            :         return;
    1234                 :            : }
    1235                 :            : 
    1236                 :            : static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
    1237                 :            : {
    1238                 :            :         return;
    1239                 :            : }
    1240                 :            : 
    1241                 :            : static inline void locks_remove_file(struct file *filp)
    1242                 :            : {
    1243                 :            :         return;
    1244                 :            : }
    1245                 :            : 
    1246                 :            : static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
    1247                 :            : {
    1248                 :            :         return;
    1249                 :            : }
    1250                 :            : 
    1251                 :            : static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
    1252                 :            :                                   struct file_lock *conflock)
    1253                 :            : {
    1254                 :            :         return -ENOLCK;
    1255                 :            : }
    1256                 :            : 
    1257                 :            : static inline int locks_delete_block(struct file_lock *waiter)
    1258                 :            : {
    1259                 :            :         return -ENOENT;
    1260                 :            : }
    1261                 :            : 
    1262                 :            : static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
    1263                 :            : {
    1264                 :            :         return 0;
    1265                 :            : }
    1266                 :            : 
    1267                 :            : static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
    1268                 :            :                                 struct file_lock *fl, struct file_lock *conf)
    1269                 :            : {
    1270                 :            :         return -ENOLCK;
    1271                 :            : }
    1272                 :            : 
    1273                 :            : static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
    1274                 :            : {
    1275                 :            :         return 0;
    1276                 :            : }
    1277                 :            : 
    1278                 :            : static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
    1279                 :            : {
    1280                 :            :         return -ENOLCK;
    1281                 :            : }
    1282                 :            : 
    1283                 :            : static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
    1284                 :            : {
    1285                 :            :         return 0;
    1286                 :            : }
    1287                 :            : 
    1288                 :            : static inline void lease_get_mtime(struct inode *inode,
    1289                 :            :                                    struct timespec64 *time)
    1290                 :            : {
    1291                 :            :         return;
    1292                 :            : }
    1293                 :            : 
    1294                 :            : static inline int generic_setlease(struct file *filp, long arg,
    1295                 :            :                                     struct file_lock **flp, void **priv)
    1296                 :            : {
    1297                 :            :         return -EINVAL;
    1298                 :            : }
    1299                 :            : 
    1300                 :            : static inline int vfs_setlease(struct file *filp, long arg,
    1301                 :            :                                struct file_lock **lease, void **priv)
    1302                 :            : {
    1303                 :            :         return -EINVAL;
    1304                 :            : }
    1305                 :            : 
    1306                 :            : static inline int lease_modify(struct file_lock *fl, int arg,
    1307                 :            :                                struct list_head *dispose)
    1308                 :            : {
    1309                 :            :         return -EINVAL;
    1310                 :            : }
    1311                 :            : 
    1312                 :            : struct files_struct;
    1313                 :            : static inline void show_fd_locks(struct seq_file *f,
    1314                 :            :                         struct file *filp, struct files_struct *files) {}
    1315                 :            : #endif /* !CONFIG_FILE_LOCKING */
    1316                 :            : 
    1317                 :            : static inline struct inode *file_inode(const struct file *f)
    1318                 :            : {
    1319                 :          3 :         return f->f_inode;
    1320                 :            : }
    1321                 :            : 
    1322                 :            : static inline struct dentry *file_dentry(const struct file *file)
    1323                 :            : {
    1324                 :          3 :         return d_real(file->f_path.dentry, file_inode(file));
    1325                 :            : }
    1326                 :            : 
    1327                 :            : static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
    1328                 :            : {
    1329                 :          3 :         return locks_lock_inode_wait(locks_inode(filp), fl);
    1330                 :            : }
    1331                 :            : 
    1332                 :            : struct fasync_struct {
    1333                 :            :         rwlock_t                fa_lock;
    1334                 :            :         int                     magic;
    1335                 :            :         int                     fa_fd;
    1336                 :            :         struct fasync_struct    *fa_next; /* singly linked list */
    1337                 :            :         struct file             *fa_file;
    1338                 :            :         struct rcu_head         fa_rcu;
    1339                 :            : };
    1340                 :            : 
    1341                 :            : #define FASYNC_MAGIC 0x4601
    1342                 :            : 
    1343                 :            : /* SMP safe fasync helpers: */
    1344                 :            : extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
    1345                 :            : extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
    1346                 :            : extern int fasync_remove_entry(struct file *, struct fasync_struct **);
    1347                 :            : extern struct fasync_struct *fasync_alloc(void);
    1348                 :            : extern void fasync_free(struct fasync_struct *);
    1349                 :            : 
    1350                 :            : /* can be called from interrupts */
    1351                 :            : extern void kill_fasync(struct fasync_struct **, int, int);
    1352                 :            : 
    1353                 :            : extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
    1354                 :            : extern int f_setown(struct file *filp, unsigned long arg, int force);
    1355                 :            : extern void f_delown(struct file *filp);
    1356                 :            : extern pid_t f_getown(struct file *filp);
    1357                 :            : extern int send_sigurg(struct fown_struct *fown);
    1358                 :            : 
    1359                 :            : /*
    1360                 :            :  * sb->s_flags.  Note that these mirror the equivalent MS_* flags where
    1361                 :            :  * represented in both.
    1362                 :            :  */
    1363                 :            : #define SB_RDONLY        1      /* Mount read-only */
    1364                 :            : #define SB_NOSUID        2      /* Ignore suid and sgid bits */
    1365                 :            : #define SB_NODEV         4      /* Disallow access to device special files */
    1366                 :            : #define SB_NOEXEC        8      /* Disallow program execution */
    1367                 :            : #define SB_SYNCHRONOUS  16      /* Writes are synced at once */
    1368                 :            : #define SB_MANDLOCK     64      /* Allow mandatory locks on an FS */
    1369                 :            : #define SB_DIRSYNC      128     /* Directory modifications are synchronous */
    1370                 :            : #define SB_NOATIME      1024    /* Do not update access times. */
    1371                 :            : #define SB_NODIRATIME   2048    /* Do not update directory access times */
    1372                 :            : #define SB_SILENT       32768
    1373                 :            : #define SB_POSIXACL     (1<<16)   /* VFS does not apply the umask */
    1374                 :            : #define SB_KERNMOUNT    (1<<22) /* this is a kern_mount call */
    1375                 :            : #define SB_I_VERSION    (1<<23) /* Update inode I_version field */
    1376                 :            : #define SB_LAZYTIME     (1<<25) /* Update the on-disk [acm]times lazily */
    1377                 :            : 
    1378                 :            : /* These sb flags are internal to the kernel */
    1379                 :            : #define SB_SUBMOUNT     (1<<26)
    1380                 :            : #define SB_FORCE        (1<<27)
    1381                 :            : #define SB_NOSEC        (1<<28)
    1382                 :            : #define SB_BORN         (1<<29)
    1383                 :            : #define SB_ACTIVE       (1<<30)
    1384                 :            : #define SB_NOUSER       (1<<31)
    1385                 :            : 
    1386                 :            : /*
    1387                 :            :  *      Umount options
    1388                 :            :  */
    1389                 :            : 
    1390                 :            : #define MNT_FORCE       0x00000001      /* Attempt to forcibily umount */
    1391                 :            : #define MNT_DETACH      0x00000002      /* Just detach from the tree */
    1392                 :            : #define MNT_EXPIRE      0x00000004      /* Mark for expiry */
    1393                 :            : #define UMOUNT_NOFOLLOW 0x00000008      /* Don't follow symlink on umount */
    1394                 :            : #define UMOUNT_UNUSED   0x80000000      /* Flag guaranteed to be unused */
    1395                 :            : 
    1396                 :            : /* sb->s_iflags */
    1397                 :            : #define SB_I_CGROUPWB   0x00000001      /* cgroup-aware writeback enabled */
    1398                 :            : #define SB_I_NOEXEC     0x00000002      /* Ignore executables on this fs */
    1399                 :            : #define SB_I_NODEV      0x00000004      /* Ignore devices on this fs */
    1400                 :            : #define SB_I_MULTIROOT  0x00000008      /* Multiple roots to the dentry tree */
    1401                 :            : 
    1402                 :            : /* sb->s_iflags to limit user namespace mounts */
    1403                 :            : #define SB_I_USERNS_VISIBLE             0x00000010 /* fstype already mounted */
    1404                 :            : #define SB_I_IMA_UNVERIFIABLE_SIGNATURE 0x00000020
    1405                 :            : #define SB_I_UNTRUSTED_MOUNTER          0x00000040
    1406                 :            : 
    1407                 :            : /* Possible states of 'frozen' field */
    1408                 :            : enum {
    1409                 :            :         SB_UNFROZEN = 0,                /* FS is unfrozen */
    1410                 :            :         SB_FREEZE_WRITE = 1,            /* Writes, dir ops, ioctls frozen */
    1411                 :            :         SB_FREEZE_PAGEFAULT = 2,        /* Page faults stopped as well */
    1412                 :            :         SB_FREEZE_FS = 3,               /* For internal FS use (e.g. to stop
    1413                 :            :                                          * internal threads if needed) */
    1414                 :            :         SB_FREEZE_COMPLETE = 4,         /* ->freeze_fs finished successfully */
    1415                 :            : };
    1416                 :            : 
    1417                 :            : #define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
    1418                 :            : 
    1419                 :            : struct sb_writers {
    1420                 :            :         int                             frozen;         /* Is sb frozen? */
    1421                 :            :         wait_queue_head_t               wait_unfrozen;  /* for get_super_thawed() */
    1422                 :            :         struct percpu_rw_semaphore      rw_sem[SB_FREEZE_LEVELS];
    1423                 :            : };
    1424                 :            : 
    1425                 :            : struct super_block {
    1426                 :            :         struct list_head        s_list;         /* Keep this first */
    1427                 :            :         dev_t                   s_dev;          /* search index; _not_ kdev_t */
    1428                 :            :         unsigned char           s_blocksize_bits;
    1429                 :            :         unsigned long           s_blocksize;
    1430                 :            :         loff_t                  s_maxbytes;     /* Max file size */
    1431                 :            :         struct file_system_type *s_type;
    1432                 :            :         const struct super_operations   *s_op;
    1433                 :            :         const struct dquot_operations   *dq_op;
    1434                 :            :         const struct quotactl_ops       *s_qcop;
    1435                 :            :         const struct export_operations *s_export_op;
    1436                 :            :         unsigned long           s_flags;
    1437                 :            :         unsigned long           s_iflags;       /* internal SB_I_* flags */
    1438                 :            :         unsigned long           s_magic;
    1439                 :            :         struct dentry           *s_root;
    1440                 :            :         struct rw_semaphore     s_umount;
    1441                 :            :         int                     s_count;
    1442                 :            :         atomic_t                s_active;
    1443                 :            : #ifdef CONFIG_SECURITY
    1444                 :            :         void                    *s_security;
    1445                 :            : #endif
    1446                 :            :         const struct xattr_handler **s_xattr;
    1447                 :            : #ifdef CONFIG_FS_ENCRYPTION
    1448                 :            :         const struct fscrypt_operations *s_cop;
    1449                 :            :         struct key              *s_master_keys; /* master crypto keys in use */
    1450                 :            : #endif
    1451                 :            : #ifdef CONFIG_FS_VERITY
    1452                 :            :         const struct fsverity_operations *s_vop;
    1453                 :            : #endif
    1454                 :            :         struct hlist_bl_head    s_roots;        /* alternate root dentries for NFS */
    1455                 :            :         struct list_head        s_mounts;       /* list of mounts; _not_ for fs use */
    1456                 :            :         struct block_device     *s_bdev;
    1457                 :            :         struct backing_dev_info *s_bdi;
    1458                 :            :         struct mtd_info         *s_mtd;
    1459                 :            :         struct hlist_node       s_instances;
    1460                 :            :         unsigned int            s_quota_types;  /* Bitmask of supported quota types */
    1461                 :            :         struct quota_info       s_dquot;        /* Diskquota specific options */
    1462                 :            : 
    1463                 :            :         struct sb_writers       s_writers;
    1464                 :            : 
    1465                 :            :         /*
    1466                 :            :          * Keep s_fs_info, s_time_gran, s_fsnotify_mask, and
    1467                 :            :          * s_fsnotify_marks together for cache efficiency. They are frequently
    1468                 :            :          * accessed and rarely modified.
    1469                 :            :          */
    1470                 :            :         void                    *s_fs_info;     /* Filesystem private info */
    1471                 :            : 
    1472                 :            :         /* Granularity of c/m/atime in ns (cannot be worse than a second) */
    1473                 :            :         u32                     s_time_gran;
    1474                 :            :         /* Time limits for c/m/atime in seconds */
    1475                 :            :         time64_t                   s_time_min;
    1476                 :            :         time64_t                   s_time_max;
    1477                 :            : #ifdef CONFIG_FSNOTIFY
    1478                 :            :         __u32                   s_fsnotify_mask;
    1479                 :            :         struct fsnotify_mark_connector __rcu    *s_fsnotify_marks;
    1480                 :            : #endif
    1481                 :            : 
    1482                 :            :         char                    s_id[32];       /* Informational name */
    1483                 :            :         uuid_t                  s_uuid;         /* UUID */
    1484                 :            : 
    1485                 :            :         unsigned int            s_max_links;
    1486                 :            :         fmode_t                 s_mode;
    1487                 :            : 
    1488                 :            :         /*
    1489                 :            :          * The next field is for VFS *only*. No filesystems have any business
    1490                 :            :          * even looking at it. You had been warned.
    1491                 :            :          */
    1492                 :            :         struct mutex s_vfs_rename_mutex;        /* Kludge */
    1493                 :            : 
    1494                 :            :         /*
    1495                 :            :          * Filesystem subtype.  If non-empty the filesystem type field
    1496                 :            :          * in /proc/mounts will be "type.subtype"
    1497                 :            :          */
    1498                 :            :         const char *s_subtype;
    1499                 :            : 
    1500                 :            :         const struct dentry_operations *s_d_op; /* default d_op for dentries */
    1501                 :            : 
    1502                 :            :         /*
    1503                 :            :          * Saved pool identifier for cleancache (-1 means none)
    1504                 :            :          */
    1505                 :            :         int cleancache_poolid;
    1506                 :            : 
    1507                 :            :         struct shrinker s_shrink;       /* per-sb shrinker handle */
    1508                 :            : 
    1509                 :            :         /* Number of inodes with nlink == 0 but still referenced */
    1510                 :            :         atomic_long_t s_remove_count;
    1511                 :            : 
    1512                 :            :         /* Pending fsnotify inode refs */
    1513                 :            :         atomic_long_t s_fsnotify_inode_refs;
    1514                 :            : 
    1515                 :            :         /* Being remounted read-only */
    1516                 :            :         int s_readonly_remount;
    1517                 :            : 
    1518                 :            :         /* AIO completions deferred from interrupt context */
    1519                 :            :         struct workqueue_struct *s_dio_done_wq;
    1520                 :            :         struct hlist_head s_pins;
    1521                 :            : 
    1522                 :            :         /*
    1523                 :            :          * Owning user namespace and default context in which to
    1524                 :            :          * interpret filesystem uids, gids, quotas, device nodes,
    1525                 :            :          * xattrs and security labels.
    1526                 :            :          */
    1527                 :            :         struct user_namespace *s_user_ns;
    1528                 :            : 
    1529                 :            :         /*
    1530                 :            :          * The list_lru structure is essentially just a pointer to a table
    1531                 :            :          * of per-node lru lists, each of which has its own spinlock.
    1532                 :            :          * There is no need to put them into separate cachelines.
    1533                 :            :          */
    1534                 :            :         struct list_lru         s_dentry_lru;
    1535                 :            :         struct list_lru         s_inode_lru;
    1536                 :            :         struct rcu_head         rcu;
    1537                 :            :         struct work_struct      destroy_work;
    1538                 :            : 
    1539                 :            :         struct mutex            s_sync_lock;    /* sync serialisation lock */
    1540                 :            : 
    1541                 :            :         /*
    1542                 :            :          * Indicates how deep in a filesystem stack this SB is
    1543                 :            :          */
    1544                 :            :         int s_stack_depth;
    1545                 :            : 
    1546                 :            :         /* s_inode_list_lock protects s_inodes */
    1547                 :            :         spinlock_t              s_inode_list_lock ____cacheline_aligned_in_smp;
    1548                 :            :         struct list_head        s_inodes;       /* all inodes */
    1549                 :            : 
    1550                 :            :         spinlock_t              s_inode_wblist_lock;
    1551                 :            :         struct list_head        s_inodes_wb;    /* writeback inodes */
    1552                 :            : } __randomize_layout;
    1553                 :            : 
    1554                 :            : /* Helper functions so that in most cases filesystems will
    1555                 :            :  * not need to deal directly with kuid_t and kgid_t and can
    1556                 :            :  * instead deal with the raw numeric values that are stored
    1557                 :            :  * in the filesystem.
    1558                 :            :  */
    1559                 :            : static inline uid_t i_uid_read(const struct inode *inode)
    1560                 :            : {
    1561                 :          3 :         return from_kuid(inode->i_sb->s_user_ns, inode->i_uid);
    1562                 :            : }
    1563                 :            : 
    1564                 :            : static inline gid_t i_gid_read(const struct inode *inode)
    1565                 :            : {
    1566                 :          3 :         return from_kgid(inode->i_sb->s_user_ns, inode->i_gid);
    1567                 :            : }
    1568                 :            : 
    1569                 :            : static inline void i_uid_write(struct inode *inode, uid_t uid)
    1570                 :            : {
    1571                 :          3 :         inode->i_uid = make_kuid(inode->i_sb->s_user_ns, uid);
    1572                 :            : }
    1573                 :            : 
    1574                 :            : static inline void i_gid_write(struct inode *inode, gid_t gid)
    1575                 :            : {
    1576                 :          3 :         inode->i_gid = make_kgid(inode->i_sb->s_user_ns, gid);
    1577                 :            : }
    1578                 :            : 
    1579                 :            : extern struct timespec64 timespec64_trunc(struct timespec64 t, unsigned gran);
    1580                 :            : extern struct timespec64 current_time(struct inode *inode);
    1581                 :            : 
    1582                 :            : /*
    1583                 :            :  * Snapshotting support.
    1584                 :            :  */
    1585                 :            : 
    1586                 :            : void __sb_end_write(struct super_block *sb, int level);
    1587                 :            : int __sb_start_write(struct super_block *sb, int level, bool wait);
    1588                 :            : 
    1589                 :            : #define __sb_writers_acquired(sb, lev)  \
    1590                 :            :         percpu_rwsem_acquire(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
    1591                 :            : #define __sb_writers_release(sb, lev)   \
    1592                 :            :         percpu_rwsem_release(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
    1593                 :            : 
    1594                 :            : /**
    1595                 :            :  * sb_end_write - drop write access to a superblock
    1596                 :            :  * @sb: the super we wrote to
    1597                 :            :  *
    1598                 :            :  * Decrement number of writers to the filesystem. Wake up possible waiters
    1599                 :            :  * wanting to freeze the filesystem.
    1600                 :            :  */
    1601                 :            : static inline void sb_end_write(struct super_block *sb)
    1602                 :            : {
    1603                 :          3 :         __sb_end_write(sb, SB_FREEZE_WRITE);
    1604                 :            : }
    1605                 :            : 
    1606                 :            : /**
    1607                 :            :  * sb_end_pagefault - drop write access to a superblock from a page fault
    1608                 :            :  * @sb: the super we wrote to
    1609                 :            :  *
    1610                 :            :  * Decrement number of processes handling write page fault to the filesystem.
    1611                 :            :  * Wake up possible waiters wanting to freeze the filesystem.
    1612                 :            :  */
    1613                 :            : static inline void sb_end_pagefault(struct super_block *sb)
    1614                 :            : {
    1615                 :          3 :         __sb_end_write(sb, SB_FREEZE_PAGEFAULT);
    1616                 :            : }
    1617                 :            : 
    1618                 :            : /**
    1619                 :            :  * sb_end_intwrite - drop write access to a superblock for internal fs purposes
    1620                 :            :  * @sb: the super we wrote to
    1621                 :            :  *
    1622                 :            :  * Decrement fs-internal number of writers to the filesystem.  Wake up possible
    1623                 :            :  * waiters wanting to freeze the filesystem.
    1624                 :            :  */
    1625                 :            : static inline void sb_end_intwrite(struct super_block *sb)
    1626                 :            : {
    1627                 :          3 :         __sb_end_write(sb, SB_FREEZE_FS);
    1628                 :            : }
    1629                 :            : 
    1630                 :            : /**
    1631                 :            :  * sb_start_write - get write access to a superblock
    1632                 :            :  * @sb: the super we write to
    1633                 :            :  *
    1634                 :            :  * When a process wants to write data or metadata to a file system (i.e. dirty
    1635                 :            :  * a page or an inode), it should embed the operation in a sb_start_write() -
    1636                 :            :  * sb_end_write() pair to get exclusion against file system freezing. This
    1637                 :            :  * function increments number of writers preventing freezing. If the file
    1638                 :            :  * system is already frozen, the function waits until the file system is
    1639                 :            :  * thawed.
    1640                 :            :  *
    1641                 :            :  * Since freeze protection behaves as a lock, users have to preserve
    1642                 :            :  * ordering of freeze protection and other filesystem locks. Generally,
    1643                 :            :  * freeze protection should be the outermost lock. In particular, we have:
    1644                 :            :  *
    1645                 :            :  * sb_start_write
    1646                 :            :  *   -> i_mutex                      (write path, truncate, directory ops, ...)
    1647                 :            :  *   -> s_umount             (freeze_super, thaw_super)
    1648                 :            :  */
    1649                 :            : static inline void sb_start_write(struct super_block *sb)
    1650                 :            : {
    1651                 :          3 :         __sb_start_write(sb, SB_FREEZE_WRITE, true);
    1652                 :            : }
    1653                 :            : 
    1654                 :            : static inline int sb_start_write_trylock(struct super_block *sb)
    1655                 :            : {
    1656                 :          3 :         return __sb_start_write(sb, SB_FREEZE_WRITE, false);
    1657                 :            : }
    1658                 :            : 
    1659                 :            : /**
    1660                 :            :  * sb_start_pagefault - get write access to a superblock from a page fault
    1661                 :            :  * @sb: the super we write to
    1662                 :            :  *
    1663                 :            :  * When a process starts handling write page fault, it should embed the
    1664                 :            :  * operation into sb_start_pagefault() - sb_end_pagefault() pair to get
    1665                 :            :  * exclusion against file system freezing. This is needed since the page fault
    1666                 :            :  * is going to dirty a page. This function increments number of running page
    1667                 :            :  * faults preventing freezing. If the file system is already frozen, the
    1668                 :            :  * function waits until the file system is thawed.
    1669                 :            :  *
    1670                 :            :  * Since page fault freeze protection behaves as a lock, users have to preserve
    1671                 :            :  * ordering of freeze protection and other filesystem locks. It is advised to
    1672                 :            :  * put sb_start_pagefault() close to mmap_sem in lock ordering. Page fault
    1673                 :            :  * handling code implies lock dependency:
    1674                 :            :  *
    1675                 :            :  * mmap_sem
    1676                 :            :  *   -> sb_start_pagefault
    1677                 :            :  */
    1678                 :            : static inline void sb_start_pagefault(struct super_block *sb)
    1679                 :            : {
    1680                 :          3 :         __sb_start_write(sb, SB_FREEZE_PAGEFAULT, true);
    1681                 :            : }
    1682                 :            : 
    1683                 :            : /*
    1684                 :            :  * sb_start_intwrite - get write access to a superblock for internal fs purposes
    1685                 :            :  * @sb: the super we write to
    1686                 :            :  *
    1687                 :            :  * This is the third level of protection against filesystem freezing. It is
    1688                 :            :  * free for use by a filesystem. The only requirement is that it must rank
    1689                 :            :  * below sb_start_pagefault.
    1690                 :            :  *
    1691                 :            :  * For example filesystem can call sb_start_intwrite() when starting a
    1692                 :            :  * transaction which somewhat eases handling of freezing for internal sources
    1693                 :            :  * of filesystem changes (internal fs threads, discarding preallocation on file
    1694                 :            :  * close, etc.).
    1695                 :            :  */
    1696                 :            : static inline void sb_start_intwrite(struct super_block *sb)
    1697                 :            : {
    1698                 :          3 :         __sb_start_write(sb, SB_FREEZE_FS, true);
    1699                 :            : }
    1700                 :            : 
    1701                 :            : static inline int sb_start_intwrite_trylock(struct super_block *sb)
    1702                 :            : {
    1703                 :          3 :         return __sb_start_write(sb, SB_FREEZE_FS, false);
    1704                 :            : }
    1705                 :            : 
    1706                 :            : 
    1707                 :            : extern bool inode_owner_or_capable(const struct inode *inode);
    1708                 :            : 
    1709                 :            : /*
    1710                 :            :  * VFS helper functions..
    1711                 :            :  */
    1712                 :            : extern int vfs_create(struct inode *, struct dentry *, umode_t, bool);
    1713                 :            : extern int vfs_mkdir(struct inode *, struct dentry *, umode_t);
    1714                 :            : extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
    1715                 :            : extern int vfs_symlink(struct inode *, struct dentry *, const char *);
    1716                 :            : extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct inode **);
    1717                 :            : extern int vfs_rmdir(struct inode *, struct dentry *);
    1718                 :            : extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
    1719                 :            : extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
    1720                 :            : extern int vfs_whiteout(struct inode *, struct dentry *);
    1721                 :            : 
    1722                 :            : extern struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode,
    1723                 :            :                                   int open_flag);
    1724                 :            : 
    1725                 :            : int vfs_mkobj(struct dentry *, umode_t,
    1726                 :            :                 int (*f)(struct dentry *, umode_t, void *),
    1727                 :            :                 void *);
    1728                 :            : 
    1729                 :            : extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
    1730                 :            : 
    1731                 :            : #ifdef CONFIG_COMPAT
    1732                 :            : extern long compat_ptr_ioctl(struct file *file, unsigned int cmd,
    1733                 :            :                                         unsigned long arg);
    1734                 :            : #else
    1735                 :            : #define compat_ptr_ioctl NULL
    1736                 :            : #endif
    1737                 :            : 
    1738                 :            : /*
    1739                 :            :  * VFS file helper functions.
    1740                 :            :  */
    1741                 :            : extern void inode_init_owner(struct inode *inode, const struct inode *dir,
    1742                 :            :                         umode_t mode);
    1743                 :            : extern bool may_open_dev(const struct path *path);
    1744                 :            : /*
    1745                 :            :  * VFS FS_IOC_FIEMAP helper definitions.
    1746                 :            :  */
    1747                 :            : struct fiemap_extent_info {
    1748                 :            :         unsigned int fi_flags;          /* Flags as passed from user */
    1749                 :            :         unsigned int fi_extents_mapped; /* Number of mapped extents */
    1750                 :            :         unsigned int fi_extents_max;    /* Size of fiemap_extent array */
    1751                 :            :         struct fiemap_extent __user *fi_extents_start; /* Start of
    1752                 :            :                                                         fiemap_extent array */
    1753                 :            : };
    1754                 :            : int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
    1755                 :            :                             u64 phys, u64 len, u32 flags);
    1756                 :            : int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
    1757                 :            : 
    1758                 :            : /*
    1759                 :            :  * This is the "filldir" function type, used by readdir() to let
    1760                 :            :  * the kernel specify what kind of dirent layout it wants to have.
    1761                 :            :  * This allows the kernel to read directories into kernel space or
    1762                 :            :  * to have different dirent layouts depending on the binary type.
    1763                 :            :  */
    1764                 :            : struct dir_context;
    1765                 :            : typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
    1766                 :            :                          unsigned);
    1767                 :            : 
    1768                 :            : struct dir_context {
    1769                 :            :         filldir_t actor;
    1770                 :            :         loff_t pos;
    1771                 :            : };
    1772                 :            : 
    1773                 :            : struct block_device_operations;
    1774                 :            : 
    1775                 :            : /* These macros are for out of kernel modules to test that
    1776                 :            :  * the kernel supports the unlocked_ioctl and compat_ioctl
    1777                 :            :  * fields in struct file_operations. */
    1778                 :            : #define HAVE_COMPAT_IOCTL 1
    1779                 :            : #define HAVE_UNLOCKED_IOCTL 1
    1780                 :            : 
    1781                 :            : /*
    1782                 :            :  * These flags let !MMU mmap() govern direct device mapping vs immediate
    1783                 :            :  * copying more easily for MAP_PRIVATE, especially for ROM filesystems.
    1784                 :            :  *
    1785                 :            :  * NOMMU_MAP_COPY:      Copy can be mapped (MAP_PRIVATE)
    1786                 :            :  * NOMMU_MAP_DIRECT:    Can be mapped directly (MAP_SHARED)
    1787                 :            :  * NOMMU_MAP_READ:      Can be mapped for reading
    1788                 :            :  * NOMMU_MAP_WRITE:     Can be mapped for writing
    1789                 :            :  * NOMMU_MAP_EXEC:      Can be mapped for execution
    1790                 :            :  */
    1791                 :            : #define NOMMU_MAP_COPY          0x00000001
    1792                 :            : #define NOMMU_MAP_DIRECT        0x00000008
    1793                 :            : #define NOMMU_MAP_READ          VM_MAYREAD
    1794                 :            : #define NOMMU_MAP_WRITE         VM_MAYWRITE
    1795                 :            : #define NOMMU_MAP_EXEC          VM_MAYEXEC
    1796                 :            : 
    1797                 :            : #define NOMMU_VMFLAGS \
    1798                 :            :         (NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
    1799                 :            : 
    1800                 :            : /*
    1801                 :            :  * These flags control the behavior of the remap_file_range function pointer.
    1802                 :            :  * If it is called with len == 0 that means "remap to end of source file".
    1803                 :            :  * See Documentation/filesystems/vfs.rst for more details about this call.
    1804                 :            :  *
    1805                 :            :  * REMAP_FILE_DEDUP: only remap if contents identical (i.e. deduplicate)
    1806                 :            :  * REMAP_FILE_CAN_SHORTEN: caller can handle a shortened request
    1807                 :            :  */
    1808                 :            : #define REMAP_FILE_DEDUP                (1 << 0)
    1809                 :            : #define REMAP_FILE_CAN_SHORTEN          (1 << 1)
    1810                 :            : 
    1811                 :            : /*
    1812                 :            :  * These flags signal that the caller is ok with altering various aspects of
    1813                 :            :  * the behavior of the remap operation.  The changes must be made by the
    1814                 :            :  * implementation; the vfs remap helper functions can take advantage of them.
    1815                 :            :  * Flags in this category exist to preserve the quirky behavior of the hoisted
    1816                 :            :  * btrfs clone/dedupe ioctls.
    1817                 :            :  */
    1818                 :            : #define REMAP_FILE_ADVISORY             (REMAP_FILE_CAN_SHORTEN)
    1819                 :            : 
    1820                 :            : struct iov_iter;
    1821                 :            : 
    1822                 :            : struct file_operations {
    1823                 :            :         struct module *owner;
    1824                 :            :         loff_t (*llseek) (struct file *, loff_t, int);
    1825                 :            :         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    1826                 :            :         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    1827                 :            :         ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
    1828                 :            :         ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
    1829                 :            :         int (*iopoll)(struct kiocb *kiocb, bool spin);
    1830                 :            :         int (*iterate) (struct file *, struct dir_context *);
    1831                 :            :         int (*iterate_shared) (struct file *, struct dir_context *);
    1832                 :            :         __poll_t (*poll) (struct file *, struct poll_table_struct *);
    1833                 :            :         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    1834                 :            :         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    1835                 :            :         int (*mmap) (struct file *, struct vm_area_struct *);
    1836                 :            :         unsigned long mmap_supported_flags;
    1837                 :            :         int (*open) (struct inode *, struct file *);
    1838                 :            :         int (*flush) (struct file *, fl_owner_t id);
    1839                 :            :         int (*release) (struct inode *, struct file *);
    1840                 :            :         int (*fsync) (struct file *, loff_t, loff_t, int datasync);
    1841                 :            :         int (*fasync) (int, struct file *, int);
    1842                 :            :         int (*lock) (struct file *, int, struct file_lock *);
    1843                 :            :         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    1844                 :            :         unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    1845                 :            :         int (*check_flags)(int);
    1846                 :            :         int (*flock) (struct file *, int, struct file_lock *);
    1847                 :            :         ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    1848                 :            :         ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    1849                 :            :         int (*setlease)(struct file *, long, struct file_lock **, void **);
    1850                 :            :         long (*fallocate)(struct file *file, int mode, loff_t offset,
    1851                 :            :                           loff_t len);
    1852                 :            :         void (*show_fdinfo)(struct seq_file *m, struct file *f);
    1853                 :            : #ifndef CONFIG_MMU
    1854                 :            :         unsigned (*mmap_capabilities)(struct file *);
    1855                 :            : #endif
    1856                 :            :         ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
    1857                 :            :                         loff_t, size_t, unsigned int);
    1858                 :            :         loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
    1859                 :            :                                    struct file *file_out, loff_t pos_out,
    1860                 :            :                                    loff_t len, unsigned int remap_flags);
    1861                 :            :         int (*fadvise)(struct file *, loff_t, loff_t, int);
    1862                 :            : } __randomize_layout;
    1863                 :            : 
    1864                 :            : struct inode_operations {
    1865                 :            :         struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
    1866                 :            :         const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
    1867                 :            :         int (*permission) (struct inode *, int);
    1868                 :            :         struct posix_acl * (*get_acl)(struct inode *, int);
    1869                 :            : 
    1870                 :            :         int (*readlink) (struct dentry *, char __user *,int);
    1871                 :            : 
    1872                 :            :         int (*create) (struct inode *,struct dentry *, umode_t, bool);
    1873                 :            :         int (*link) (struct dentry *,struct inode *,struct dentry *);
    1874                 :            :         int (*unlink) (struct inode *,struct dentry *);
    1875                 :            :         int (*symlink) (struct inode *,struct dentry *,const char *);
    1876                 :            :         int (*mkdir) (struct inode *,struct dentry *,umode_t);
    1877                 :            :         int (*rmdir) (struct inode *,struct dentry *);
    1878                 :            :         int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
    1879                 :            :         int (*rename) (struct inode *, struct dentry *,
    1880                 :            :                         struct inode *, struct dentry *, unsigned int);
    1881                 :            :         int (*setattr) (struct dentry *, struct iattr *);
    1882                 :            :         int (*getattr) (const struct path *, struct kstat *, u32, unsigned int);
    1883                 :            :         ssize_t (*listxattr) (struct dentry *, char *, size_t);
    1884                 :            :         int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
    1885                 :            :                       u64 len);
    1886                 :            :         int (*update_time)(struct inode *, struct timespec64 *, int);
    1887                 :            :         int (*atomic_open)(struct inode *, struct dentry *,
    1888                 :            :                            struct file *, unsigned open_flag,
    1889                 :            :                            umode_t create_mode);
    1890                 :            :         int (*tmpfile) (struct inode *, struct dentry *, umode_t);
    1891                 :            :         int (*set_acl)(struct inode *, struct posix_acl *, int);
    1892                 :            : } ____cacheline_aligned;
    1893                 :            : 
    1894                 :            : static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
    1895                 :            :                                      struct iov_iter *iter)
    1896                 :            : {
    1897                 :          3 :         return file->f_op->read_iter(kio, iter);
    1898                 :            : }
    1899                 :            : 
    1900                 :            : static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio,
    1901                 :            :                                       struct iov_iter *iter)
    1902                 :            : {
    1903                 :          3 :         return file->f_op->write_iter(kio, iter);
    1904                 :            : }
    1905                 :            : 
    1906                 :            : static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
    1907                 :            : {
    1908                 :          3 :         return file->f_op->mmap(file, vma);
    1909                 :            : }
    1910                 :            : 
    1911                 :            : ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
    1912                 :            :                               unsigned long nr_segs, unsigned long fast_segs,
    1913                 :            :                               struct iovec *fast_pointer,
    1914                 :            :                               struct iovec **ret_pointer);
    1915                 :            : 
    1916                 :            : extern ssize_t __vfs_read(struct file *, char __user *, size_t, loff_t *);
    1917                 :            : extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
    1918                 :            : extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
    1919                 :            : extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
    1920                 :            :                 unsigned long, loff_t *, rwf_t);
    1921                 :            : extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
    1922                 :            :                                    loff_t, size_t, unsigned int);
    1923                 :            : extern ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in,
    1924                 :            :                                        struct file *file_out, loff_t pos_out,
    1925                 :            :                                        size_t len, unsigned int flags);
    1926                 :            : extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
    1927                 :            :                                          struct file *file_out, loff_t pos_out,
    1928                 :            :                                          loff_t *count,
    1929                 :            :                                          unsigned int remap_flags);
    1930                 :            : extern loff_t do_clone_file_range(struct file *file_in, loff_t pos_in,
    1931                 :            :                                   struct file *file_out, loff_t pos_out,
    1932                 :            :                                   loff_t len, unsigned int remap_flags);
    1933                 :            : extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
    1934                 :            :                                    struct file *file_out, loff_t pos_out,
    1935                 :            :                                    loff_t len, unsigned int remap_flags);
    1936                 :            : extern int vfs_dedupe_file_range(struct file *file,
    1937                 :            :                                  struct file_dedupe_range *same);
    1938                 :            : extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
    1939                 :            :                                         struct file *dst_file, loff_t dst_pos,
    1940                 :            :                                         loff_t len, unsigned int remap_flags);
    1941                 :            : 
    1942                 :            : 
    1943                 :            : struct super_operations {
    1944                 :            :         struct inode *(*alloc_inode)(struct super_block *sb);
    1945                 :            :         void (*destroy_inode)(struct inode *);
    1946                 :            :         void (*free_inode)(struct inode *);
    1947                 :            : 
    1948                 :            :         void (*dirty_inode) (struct inode *, int flags);
    1949                 :            :         int (*write_inode) (struct inode *, struct writeback_control *wbc);
    1950                 :            :         int (*drop_inode) (struct inode *);
    1951                 :            :         void (*evict_inode) (struct inode *);
    1952                 :            :         void (*put_super) (struct super_block *);
    1953                 :            :         int (*sync_fs)(struct super_block *sb, int wait);
    1954                 :            :         int (*freeze_super) (struct super_block *);
    1955                 :            :         int (*freeze_fs) (struct super_block *);
    1956                 :            :         int (*thaw_super) (struct super_block *);
    1957                 :            :         int (*unfreeze_fs) (struct super_block *);
    1958                 :            :         int (*statfs) (struct dentry *, struct kstatfs *);
    1959                 :            :         int (*remount_fs) (struct super_block *, int *, char *);
    1960                 :            :         void (*umount_begin) (struct super_block *);
    1961                 :            : 
    1962                 :            :         int (*show_options)(struct seq_file *, struct dentry *);
    1963                 :            :         int (*show_devname)(struct seq_file *, struct dentry *);
    1964                 :            :         int (*show_path)(struct seq_file *, struct dentry *);
    1965                 :            :         int (*show_stats)(struct seq_file *, struct dentry *);
    1966                 :            : #ifdef CONFIG_QUOTA
    1967                 :            :         ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
    1968                 :            :         ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
    1969                 :            :         struct dquot **(*get_dquots)(struct inode *);
    1970                 :            : #endif
    1971                 :            :         int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
    1972                 :            :         long (*nr_cached_objects)(struct super_block *,
    1973                 :            :                                   struct shrink_control *);
    1974                 :            :         long (*free_cached_objects)(struct super_block *,
    1975                 :            :                                     struct shrink_control *);
    1976                 :            : };
    1977                 :            : 
    1978                 :            : /*
    1979                 :            :  * Inode flags - they have no relation to superblock flags now
    1980                 :            :  */
    1981                 :            : #define S_SYNC          1       /* Writes are synced at once */
    1982                 :            : #define S_NOATIME       2       /* Do not update access times */
    1983                 :            : #define S_APPEND        4       /* Append-only file */
    1984                 :            : #define S_IMMUTABLE     8       /* Immutable file */
    1985                 :            : #define S_DEAD          16      /* removed, but still open directory */
    1986                 :            : #define S_NOQUOTA       32      /* Inode is not counted to quota */
    1987                 :            : #define S_DIRSYNC       64      /* Directory modifications are synchronous */
    1988                 :            : #define S_NOCMTIME      128     /* Do not update file c/mtime */
    1989                 :            : #define S_SWAPFILE      256     /* Do not truncate: swapon got its bmaps */
    1990                 :            : #define S_PRIVATE       512     /* Inode is fs-internal */
    1991                 :            : #define S_IMA           1024    /* Inode has an associated IMA struct */
    1992                 :            : #define S_AUTOMOUNT     2048    /* Automount/referral quasi-directory */
    1993                 :            : #define S_NOSEC         4096    /* no suid or xattr security attributes */
    1994                 :            : #ifdef CONFIG_FS_DAX
    1995                 :            : #define S_DAX           8192    /* Direct Access, avoiding the page cache */
    1996                 :            : #else
    1997                 :            : #define S_DAX           0       /* Make all the DAX code disappear */
    1998                 :            : #endif
    1999                 :            : #define S_ENCRYPTED     16384   /* Encrypted file (using fs/crypto/) */
    2000                 :            : #define S_CASEFOLD      32768   /* Casefolded file */
    2001                 :            : #define S_VERITY        65536   /* Verity file (using fs/verity/) */
    2002                 :            : 
    2003                 :            : /*
    2004                 :            :  * Note that nosuid etc flags are inode-specific: setting some file-system
    2005                 :            :  * flags just means all the inodes inherit those flags by default. It might be
    2006                 :            :  * possible to override it selectively if you really wanted to with some
    2007                 :            :  * ioctl() that is not currently implemented.
    2008                 :            :  *
    2009                 :            :  * Exception: SB_RDONLY is always applied to the entire file system.
    2010                 :            :  *
    2011                 :            :  * Unfortunately, it is possible to change a filesystems flags with it mounted
    2012                 :            :  * with files in use.  This means that all of the inodes will not have their
    2013                 :            :  * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
    2014                 :            :  * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
    2015                 :            :  */
    2016                 :            : #define __IS_FLG(inode, flg)    ((inode)->i_sb->s_flags & (flg))
    2017                 :            : 
    2018                 :          3 : static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; }
    2019                 :            : #define IS_RDONLY(inode)        sb_rdonly((inode)->i_sb)
    2020                 :            : #define IS_SYNC(inode)          (__IS_FLG(inode, SB_SYNCHRONOUS) || \
    2021                 :            :                                         ((inode)->i_flags & S_SYNC))
    2022                 :            : #define IS_DIRSYNC(inode)       (__IS_FLG(inode, SB_SYNCHRONOUS|SB_DIRSYNC) || \
    2023                 :            :                                         ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
    2024                 :            : #define IS_MANDLOCK(inode)      __IS_FLG(inode, SB_MANDLOCK)
    2025                 :            : #define IS_NOATIME(inode)       __IS_FLG(inode, SB_RDONLY|SB_NOATIME)
    2026                 :            : #define IS_I_VERSION(inode)     __IS_FLG(inode, SB_I_VERSION)
    2027                 :            : 
    2028                 :            : #define IS_NOQUOTA(inode)       ((inode)->i_flags & S_NOQUOTA)
    2029                 :            : #define IS_APPEND(inode)        ((inode)->i_flags & S_APPEND)
    2030                 :            : #define IS_IMMUTABLE(inode)     ((inode)->i_flags & S_IMMUTABLE)
    2031                 :            : #define IS_POSIXACL(inode)      __IS_FLG(inode, SB_POSIXACL)
    2032                 :            : 
    2033                 :            : #define IS_DEADDIR(inode)       ((inode)->i_flags & S_DEAD)
    2034                 :            : #define IS_NOCMTIME(inode)      ((inode)->i_flags & S_NOCMTIME)
    2035                 :            : #define IS_SWAPFILE(inode)      ((inode)->i_flags & S_SWAPFILE)
    2036                 :            : #define IS_PRIVATE(inode)       ((inode)->i_flags & S_PRIVATE)
    2037                 :            : #define IS_IMA(inode)           ((inode)->i_flags & S_IMA)
    2038                 :            : #define IS_AUTOMOUNT(inode)     ((inode)->i_flags & S_AUTOMOUNT)
    2039                 :            : #define IS_NOSEC(inode)         ((inode)->i_flags & S_NOSEC)
    2040                 :            : #define IS_DAX(inode)           ((inode)->i_flags & S_DAX)
    2041                 :            : #define IS_ENCRYPTED(inode)     ((inode)->i_flags & S_ENCRYPTED)
    2042                 :            : #define IS_CASEFOLDED(inode)    ((inode)->i_flags & S_CASEFOLD)
    2043                 :            : #define IS_VERITY(inode)        ((inode)->i_flags & S_VERITY)
    2044                 :            : 
    2045                 :            : #define IS_WHITEOUT(inode)      (S_ISCHR(inode->i_mode) && \
    2046                 :            :                                  (inode)->i_rdev == WHITEOUT_DEV)
    2047                 :            : 
    2048                 :            : static inline bool HAS_UNMAPPED_ID(struct inode *inode)
    2049                 :            : {
    2050                 :          3 :         return !uid_valid(inode->i_uid) || !gid_valid(inode->i_gid);
    2051                 :            : }
    2052                 :            : 
    2053                 :            : static inline enum rw_hint file_write_hint(struct file *file)
    2054                 :            : {
    2055                 :          3 :         if (file->f_write_hint != WRITE_LIFE_NOT_SET)
    2056                 :            :                 return file->f_write_hint;
    2057                 :            : 
    2058                 :          3 :         return file_inode(file)->i_write_hint;
    2059                 :            : }
    2060                 :            : 
    2061                 :            : static inline int iocb_flags(struct file *file);
    2062                 :            : 
    2063                 :            : static inline u16 ki_hint_validate(enum rw_hint hint)
    2064                 :            : {
    2065                 :            :         typeof(((struct kiocb *)0)->ki_hint) max_hint = -1;
    2066                 :            : 
    2067                 :          3 :         if (hint <= max_hint)
    2068                 :          3 :                 return hint;
    2069                 :            :         return 0;
    2070                 :            : }
    2071                 :            : 
    2072                 :          3 : static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
    2073                 :            : {
    2074                 :          3 :         *kiocb = (struct kiocb) {
    2075                 :            :                 .ki_filp = filp,
    2076                 :          3 :                 .ki_flags = iocb_flags(filp),
    2077                 :            :                 .ki_hint = ki_hint_validate(file_write_hint(filp)),
    2078                 :            :                 .ki_ioprio = get_current_ioprio(),
    2079                 :            :         };
    2080                 :          3 : }
    2081                 :            : 
    2082                 :            : /*
    2083                 :            :  * Inode state bits.  Protected by inode->i_lock
    2084                 :            :  *
    2085                 :            :  * Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
    2086                 :            :  * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
    2087                 :            :  *
    2088                 :            :  * Four bits define the lifetime of an inode.  Initially, inodes are I_NEW,
    2089                 :            :  * until that flag is cleared.  I_WILL_FREE, I_FREEING and I_CLEAR are set at
    2090                 :            :  * various stages of removing an inode.
    2091                 :            :  *
    2092                 :            :  * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
    2093                 :            :  *
    2094                 :            :  * I_DIRTY_SYNC         Inode is dirty, but doesn't have to be written on
    2095                 :            :  *                      fdatasync().  i_atime is the usual cause.
    2096                 :            :  * I_DIRTY_DATASYNC     Data-related inode changes pending. We keep track of
    2097                 :            :  *                      these changes separately from I_DIRTY_SYNC so that we
    2098                 :            :  *                      don't have to write inode on fdatasync() when only
    2099                 :            :  *                      mtime has changed in it.
    2100                 :            :  * I_DIRTY_PAGES        Inode has dirty pages.  Inode itself may be clean.
    2101                 :            :  * I_NEW                Serves as both a mutex and completion notification.
    2102                 :            :  *                      New inodes set I_NEW.  If two processes both create
    2103                 :            :  *                      the same inode, one of them will release its inode and
    2104                 :            :  *                      wait for I_NEW to be released before returning.
    2105                 :            :  *                      Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
    2106                 :            :  *                      also cause waiting on I_NEW, without I_NEW actually
    2107                 :            :  *                      being set.  find_inode() uses this to prevent returning
    2108                 :            :  *                      nearly-dead inodes.
    2109                 :            :  * I_WILL_FREE          Must be set when calling write_inode_now() if i_count
    2110                 :            :  *                      is zero.  I_FREEING must be set when I_WILL_FREE is
    2111                 :            :  *                      cleared.
    2112                 :            :  * I_FREEING            Set when inode is about to be freed but still has dirty
    2113                 :            :  *                      pages or buffers attached or the inode itself is still
    2114                 :            :  *                      dirty.
    2115                 :            :  * I_CLEAR              Added by clear_inode().  In this state the inode is
    2116                 :            :  *                      clean and can be destroyed.  Inode keeps I_FREEING.
    2117                 :            :  *
    2118                 :            :  *                      Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
    2119                 :            :  *                      prohibited for many purposes.  iget() must wait for
    2120                 :            :  *                      the inode to be completely released, then create it
    2121                 :            :  *                      anew.  Other functions will just ignore such inodes,
    2122                 :            :  *                      if appropriate.  I_NEW is used for waiting.
    2123                 :            :  *
    2124                 :            :  * I_SYNC               Writeback of inode is running. The bit is set during
    2125                 :            :  *                      data writeback, and cleared with a wakeup on the bit
    2126                 :            :  *                      address once it is done. The bit is also used to pin
    2127                 :            :  *                      the inode in memory for flusher thread.
    2128                 :            :  *
    2129                 :            :  * I_REFERENCED         Marks the inode as recently references on the LRU list.
    2130                 :            :  *
    2131                 :            :  * I_DIO_WAKEUP         Never set.  Only used as a key for wait_on_bit().
    2132                 :            :  *
    2133                 :            :  * I_WB_SWITCH          Cgroup bdi_writeback switching in progress.  Used to
    2134                 :            :  *                      synchronize competing switching instances and to tell
    2135                 :            :  *                      wb stat updates to grab the i_pages lock.  See
    2136                 :            :  *                      inode_switch_wbs_work_fn() for details.
    2137                 :            :  *
    2138                 :            :  * I_OVL_INUSE          Used by overlayfs to get exclusive ownership on upper
    2139                 :            :  *                      and work dirs among overlayfs mounts.
    2140                 :            :  *
    2141                 :            :  * I_CREATING           New object's inode in the middle of setting up.
    2142                 :            :  *
    2143                 :            :  * Q: What is the difference between I_WILL_FREE and I_FREEING?
    2144                 :            :  */
    2145                 :            : #define I_DIRTY_SYNC            (1 << 0)
    2146                 :            : #define I_DIRTY_DATASYNC        (1 << 1)
    2147                 :            : #define I_DIRTY_PAGES           (1 << 2)
    2148                 :            : #define __I_NEW                 3
    2149                 :            : #define I_NEW                   (1 << __I_NEW)
    2150                 :            : #define I_WILL_FREE             (1 << 4)
    2151                 :            : #define I_FREEING               (1 << 5)
    2152                 :            : #define I_CLEAR                 (1 << 6)
    2153                 :            : #define __I_SYNC                7
    2154                 :            : #define I_SYNC                  (1 << __I_SYNC)
    2155                 :            : #define I_REFERENCED            (1 << 8)
    2156                 :            : #define __I_DIO_WAKEUP          9
    2157                 :            : #define I_DIO_WAKEUP            (1 << __I_DIO_WAKEUP)
    2158                 :            : #define I_LINKABLE              (1 << 10)
    2159                 :            : #define I_DIRTY_TIME            (1 << 11)
    2160                 :            : #define __I_DIRTY_TIME_EXPIRED  12
    2161                 :            : #define I_DIRTY_TIME_EXPIRED    (1 << __I_DIRTY_TIME_EXPIRED)
    2162                 :            : #define I_WB_SWITCH             (1 << 13)
    2163                 :            : #define I_OVL_INUSE             (1 << 14)
    2164                 :            : #define I_CREATING              (1 << 15)
    2165                 :            : 
    2166                 :            : #define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
    2167                 :            : #define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
    2168                 :            : #define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
    2169                 :            : 
    2170                 :            : extern void __mark_inode_dirty(struct inode *, int);
    2171                 :            : static inline void mark_inode_dirty(struct inode *inode)
    2172                 :            : {
    2173                 :          3 :         __mark_inode_dirty(inode, I_DIRTY);
    2174                 :            : }
    2175                 :            : 
    2176                 :            : static inline void mark_inode_dirty_sync(struct inode *inode)
    2177                 :            : {
    2178                 :          3 :         __mark_inode_dirty(inode, I_DIRTY_SYNC);
    2179                 :            : }
    2180                 :            : 
    2181                 :            : extern void inc_nlink(struct inode *inode);
    2182                 :            : extern void drop_nlink(struct inode *inode);
    2183                 :            : extern void clear_nlink(struct inode *inode);
    2184                 :            : extern void set_nlink(struct inode *inode, unsigned int nlink);
    2185                 :            : 
    2186                 :            : static inline void inode_inc_link_count(struct inode *inode)
    2187                 :            : {
    2188                 :            :         inc_nlink(inode);
    2189                 :            :         mark_inode_dirty(inode);
    2190                 :            : }
    2191                 :            : 
    2192                 :            : static inline void inode_dec_link_count(struct inode *inode)
    2193                 :            : {
    2194                 :          3 :         drop_nlink(inode);
    2195                 :            :         mark_inode_dirty(inode);
    2196                 :            : }
    2197                 :            : 
    2198                 :            : enum file_time_flags {
    2199                 :            :         S_ATIME = 1,
    2200                 :            :         S_MTIME = 2,
    2201                 :            :         S_CTIME = 4,
    2202                 :            :         S_VERSION = 8,
    2203                 :            : };
    2204                 :            : 
    2205                 :            : extern bool atime_needs_update(const struct path *, struct inode *);
    2206                 :            : extern void touch_atime(const struct path *);
    2207                 :            : static inline void file_accessed(struct file *file)
    2208                 :            : {
    2209                 :          3 :         if (!(file->f_flags & O_NOATIME))
    2210                 :          3 :                 touch_atime(&file->f_path);
    2211                 :            : }
    2212                 :            : 
    2213                 :            : extern int file_modified(struct file *file);
    2214                 :            : 
    2215                 :            : int sync_inode(struct inode *inode, struct writeback_control *wbc);
    2216                 :            : int sync_inode_metadata(struct inode *inode, int wait);
    2217                 :            : 
    2218                 :            : struct file_system_type {
    2219                 :            :         const char *name;
    2220                 :            :         int fs_flags;
    2221                 :            : #define FS_REQUIRES_DEV         1 
    2222                 :            : #define FS_BINARY_MOUNTDATA     2
    2223                 :            : #define FS_HAS_SUBTYPE          4
    2224                 :            : #define FS_USERNS_MOUNT         8       /* Can be mounted by userns root */
    2225                 :            : #define FS_DISALLOW_NOTIFY_PERM 16      /* Disable fanotify permission events */
    2226                 :            : #define FS_RENAME_DOES_D_MOVE   32768   /* FS will handle d_move() during rename() internally. */
    2227                 :            :         int (*init_fs_context)(struct fs_context *);
    2228                 :            :         const struct fs_parameter_description *parameters;
    2229                 :            :         struct dentry *(*mount) (struct file_system_type *, int,
    2230                 :            :                        const char *, void *);
    2231                 :            :         void (*kill_sb) (struct super_block *);
    2232                 :            :         struct module *owner;
    2233                 :            :         struct file_system_type * next;
    2234                 :            :         struct hlist_head fs_supers;
    2235                 :            : 
    2236                 :            :         struct lock_class_key s_lock_key;
    2237                 :            :         struct lock_class_key s_umount_key;
    2238                 :            :         struct lock_class_key s_vfs_rename_key;
    2239                 :            :         struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
    2240                 :            : 
    2241                 :            :         struct lock_class_key i_lock_key;
    2242                 :            :         struct lock_class_key i_mutex_key;
    2243                 :            :         struct lock_class_key i_mutex_dir_key;
    2244                 :            : };
    2245                 :            : 
    2246                 :            : #define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
    2247                 :            : 
    2248                 :            : #ifdef CONFIG_BLOCK
    2249                 :            : extern struct dentry *mount_bdev(struct file_system_type *fs_type,
    2250                 :            :         int flags, const char *dev_name, void *data,
    2251                 :            :         int (*fill_super)(struct super_block *, void *, int));
    2252                 :            : #else
    2253                 :            : static inline struct dentry *mount_bdev(struct file_system_type *fs_type,
    2254                 :            :         int flags, const char *dev_name, void *data,
    2255                 :            :         int (*fill_super)(struct super_block *, void *, int))
    2256                 :            : {
    2257                 :            :         return ERR_PTR(-ENODEV);
    2258                 :            : }
    2259                 :            : #endif
    2260                 :            : extern struct dentry *mount_single(struct file_system_type *fs_type,
    2261                 :            :         int flags, void *data,
    2262                 :            :         int (*fill_super)(struct super_block *, void *, int));
    2263                 :            : extern struct dentry *mount_nodev(struct file_system_type *fs_type,
    2264                 :            :         int flags, void *data,
    2265                 :            :         int (*fill_super)(struct super_block *, void *, int));
    2266                 :            : extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
    2267                 :            : void generic_shutdown_super(struct super_block *sb);
    2268                 :            : #ifdef CONFIG_BLOCK
    2269                 :            : void kill_block_super(struct super_block *sb);
    2270                 :            : #else
    2271                 :            : static inline void kill_block_super(struct super_block *sb)
    2272                 :            : {
    2273                 :            :         BUG();
    2274                 :            : }
    2275                 :            : #endif
    2276                 :            : void kill_anon_super(struct super_block *sb);
    2277                 :            : void kill_litter_super(struct super_block *sb);
    2278                 :            : void deactivate_super(struct super_block *sb);
    2279                 :            : void deactivate_locked_super(struct super_block *sb);
    2280                 :            : int set_anon_super(struct super_block *s, void *data);
    2281                 :            : int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
    2282                 :            : int get_anon_bdev(dev_t *);
    2283                 :            : void free_anon_bdev(dev_t);
    2284                 :            : struct super_block *sget_fc(struct fs_context *fc,
    2285                 :            :                             int (*test)(struct super_block *, struct fs_context *),
    2286                 :            :                             int (*set)(struct super_block *, struct fs_context *));
    2287                 :            : struct super_block *sget(struct file_system_type *type,
    2288                 :            :                         int (*test)(struct super_block *,void *),
    2289                 :            :                         int (*set)(struct super_block *,void *),
    2290                 :            :                         int flags, void *data);
    2291                 :            : 
    2292                 :            : /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
    2293                 :            : #define fops_get(fops) \
    2294                 :            :         (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
    2295                 :            : #define fops_put(fops) \
    2296                 :            :         do { if (fops) module_put((fops)->owner); } while(0)
    2297                 :            : /*
    2298                 :            :  * This one is to be used *ONLY* from ->open() instances.
    2299                 :            :  * fops must be non-NULL, pinned down *and* module dependencies
    2300                 :            :  * should be sufficient to pin the caller down as well.
    2301                 :            :  */
    2302                 :            : #define replace_fops(f, fops) \
    2303                 :            :         do {    \
    2304                 :            :                 struct file *__file = (f); \
    2305                 :            :                 fops_put(__file->f_op); \
    2306                 :            :                 BUG_ON(!(__file->f_op = (fops))); \
    2307                 :            :         } while(0)
    2308                 :            : 
    2309                 :            : extern int register_filesystem(struct file_system_type *);
    2310                 :            : extern int unregister_filesystem(struct file_system_type *);
    2311                 :            : extern struct vfsmount *kern_mount(struct file_system_type *);
    2312                 :            : extern void kern_unmount(struct vfsmount *mnt);
    2313                 :            : extern int may_umount_tree(struct vfsmount *);
    2314                 :            : extern int may_umount(struct vfsmount *);
    2315                 :            : extern long do_mount(const char *, const char __user *,
    2316                 :            :                      const char *, unsigned long, void *);
    2317                 :            : extern struct vfsmount *collect_mounts(const struct path *);
    2318                 :            : extern void drop_collected_mounts(struct vfsmount *);
    2319                 :            : extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
    2320                 :            :                           struct vfsmount *);
    2321                 :            : extern int vfs_statfs(const struct path *, struct kstatfs *);
    2322                 :            : extern int user_statfs(const char __user *, struct kstatfs *);
    2323                 :            : extern int fd_statfs(int, struct kstatfs *);
    2324                 :            : extern int freeze_super(struct super_block *super);
    2325                 :            : extern int thaw_super(struct super_block *super);
    2326                 :            : extern bool our_mnt(struct vfsmount *mnt);
    2327                 :            : extern __printf(2, 3)
    2328                 :            : int super_setup_bdi_name(struct super_block *sb, char *fmt, ...);
    2329                 :            : extern int super_setup_bdi(struct super_block *sb);
    2330                 :            : 
    2331                 :            : extern int current_umask(void);
    2332                 :            : 
    2333                 :            : extern void ihold(struct inode * inode);
    2334                 :            : extern void iput(struct inode *);
    2335                 :            : extern int generic_update_time(struct inode *, struct timespec64 *, int);
    2336                 :            : 
    2337                 :            : /* /sys/fs */
    2338                 :            : extern struct kobject *fs_kobj;
    2339                 :            : 
    2340                 :            : #define MAX_RW_COUNT (INT_MAX & PAGE_MASK)
    2341                 :            : 
    2342                 :            : #ifdef CONFIG_MANDATORY_FILE_LOCKING
    2343                 :            : extern int locks_mandatory_locked(struct file *);
    2344                 :            : extern int locks_mandatory_area(struct inode *, struct file *, loff_t, loff_t, unsigned char);
    2345                 :            : 
    2346                 :            : /*
    2347                 :            :  * Candidates for mandatory locking have the setgid bit set
    2348                 :            :  * but no group execute bit -  an otherwise meaningless combination.
    2349                 :            :  */
    2350                 :            : 
    2351                 :            : static inline int __mandatory_lock(struct inode *ino)
    2352                 :            : {
    2353                 :          0 :         return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
    2354                 :            : }
    2355                 :            : 
    2356                 :            : /*
    2357                 :            :  * ... and these candidates should be on SB_MANDLOCK mounted fs,
    2358                 :            :  * otherwise these will be advisory locks
    2359                 :            :  */
    2360                 :            : 
    2361                 :            : static inline int mandatory_lock(struct inode *ino)
    2362                 :            : {
    2363                 :          3 :         return IS_MANDLOCK(ino) && __mandatory_lock(ino);
    2364                 :            : }
    2365                 :            : 
    2366                 :          3 : static inline int locks_verify_locked(struct file *file)
    2367                 :            : {
    2368                 :          3 :         if (mandatory_lock(locks_inode(file)))
    2369                 :          0 :                 return locks_mandatory_locked(file);
    2370                 :            :         return 0;
    2371                 :            : }
    2372                 :            : 
    2373                 :          3 : static inline int locks_verify_truncate(struct inode *inode,
    2374                 :            :                                     struct file *f,
    2375                 :            :                                     loff_t size)
    2376                 :            : {
    2377                 :          3 :         if (!inode->i_flctx || !mandatory_lock(inode))
    2378                 :            :                 return 0;
    2379                 :            : 
    2380                 :          0 :         if (size < inode->i_size) {
    2381                 :          0 :                 return locks_mandatory_area(inode, f, size, inode->i_size - 1,
    2382                 :            :                                 F_WRLCK);
    2383                 :            :         } else {
    2384                 :          0 :                 return locks_mandatory_area(inode, f, inode->i_size, size - 1,
    2385                 :            :                                 F_WRLCK);
    2386                 :            :         }
    2387                 :            : }
    2388                 :            : 
    2389                 :            : #else /* !CONFIG_MANDATORY_FILE_LOCKING */
    2390                 :            : 
    2391                 :            : static inline int locks_mandatory_locked(struct file *file)
    2392                 :            : {
    2393                 :            :         return 0;
    2394                 :            : }
    2395                 :            : 
    2396                 :            : static inline int locks_mandatory_area(struct inode *inode, struct file *filp,
    2397                 :            :                                        loff_t start, loff_t end, unsigned char type)
    2398                 :            : {
    2399                 :            :         return 0;
    2400                 :            : }
    2401                 :            : 
    2402                 :            : static inline int __mandatory_lock(struct inode *inode)
    2403                 :            : {
    2404                 :            :         return 0;
    2405                 :            : }
    2406                 :            : 
    2407                 :            : static inline int mandatory_lock(struct inode *inode)
    2408                 :            : {
    2409                 :            :         return 0;
    2410                 :            : }
    2411                 :            : 
    2412                 :            : static inline int locks_verify_locked(struct file *file)
    2413                 :            : {
    2414                 :            :         return 0;
    2415                 :            : }
    2416                 :            : 
    2417                 :            : static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
    2418                 :            :                                         size_t size)
    2419                 :            : {
    2420                 :            :         return 0;
    2421                 :            : }
    2422                 :            : 
    2423                 :            : #endif /* CONFIG_MANDATORY_FILE_LOCKING */
    2424                 :            : 
    2425                 :            : 
    2426                 :            : #ifdef CONFIG_FILE_LOCKING
    2427                 :          3 : static inline int break_lease(struct inode *inode, unsigned int mode)
    2428                 :            : {
    2429                 :            :         /*
    2430                 :            :          * Since this check is lockless, we must ensure that any refcounts
    2431                 :            :          * taken are done before checking i_flctx->flc_lease. Otherwise, we
    2432                 :            :          * could end up racing with tasks trying to set a new lease on this
    2433                 :            :          * file.
    2434                 :            :          */
    2435                 :          3 :         smp_mb();
    2436                 :          3 :         if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
    2437                 :          0 :                 return __break_lease(inode, mode, FL_LEASE);
    2438                 :            :         return 0;
    2439                 :            : }
    2440                 :            : 
    2441                 :          3 : static inline int break_deleg(struct inode *inode, unsigned int mode)
    2442                 :            : {
    2443                 :            :         /*
    2444                 :            :          * Since this check is lockless, we must ensure that any refcounts
    2445                 :            :          * taken are done before checking i_flctx->flc_lease. Otherwise, we
    2446                 :            :          * could end up racing with tasks trying to set a new lease on this
    2447                 :            :          * file.
    2448                 :            :          */
    2449                 :          3 :         smp_mb();
    2450                 :          3 :         if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
    2451                 :          0 :                 return __break_lease(inode, mode, FL_DELEG);
    2452                 :            :         return 0;
    2453                 :            : }
    2454                 :            : 
    2455                 :          3 : static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
    2456                 :            : {
    2457                 :            :         int ret;
    2458                 :            : 
    2459                 :          3 :         ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
    2460                 :          3 :         if (ret == -EWOULDBLOCK && delegated_inode) {
    2461                 :          0 :                 *delegated_inode = inode;
    2462                 :          0 :                 ihold(inode);
    2463                 :            :         }
    2464                 :          3 :         return ret;
    2465                 :            : }
    2466                 :            : 
    2467                 :          0 : static inline int break_deleg_wait(struct inode **delegated_inode)
    2468                 :            : {
    2469                 :            :         int ret;
    2470                 :            : 
    2471                 :          0 :         ret = break_deleg(*delegated_inode, O_WRONLY);
    2472                 :          0 :         iput(*delegated_inode);
    2473                 :          0 :         *delegated_inode = NULL;
    2474                 :          0 :         return ret;
    2475                 :            : }
    2476                 :            : 
    2477                 :            : static inline int break_layout(struct inode *inode, bool wait)
    2478                 :            : {
    2479                 :            :         smp_mb();
    2480                 :            :         if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
    2481                 :            :                 return __break_lease(inode,
    2482                 :            :                                 wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
    2483                 :            :                                 FL_LAYOUT);
    2484                 :            :         return 0;
    2485                 :            : }
    2486                 :            : 
    2487                 :            : #else /* !CONFIG_FILE_LOCKING */
    2488                 :            : static inline int break_lease(struct inode *inode, unsigned int mode)
    2489                 :            : {
    2490                 :            :         return 0;
    2491                 :            : }
    2492                 :            : 
    2493                 :            : static inline int break_deleg(struct inode *inode, unsigned int mode)
    2494                 :            : {
    2495                 :            :         return 0;
    2496                 :            : }
    2497                 :            : 
    2498                 :            : static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
    2499                 :            : {
    2500                 :            :         return 0;
    2501                 :            : }
    2502                 :            : 
    2503                 :            : static inline int break_deleg_wait(struct inode **delegated_inode)
    2504                 :            : {
    2505                 :            :         BUG();
    2506                 :            :         return 0;
    2507                 :            : }
    2508                 :            : 
    2509                 :            : static inline int break_layout(struct inode *inode, bool wait)
    2510                 :            : {
    2511                 :            :         return 0;
    2512                 :            : }
    2513                 :            : 
    2514                 :            : #endif /* CONFIG_FILE_LOCKING */
    2515                 :            : 
    2516                 :            : /* fs/open.c */
    2517                 :            : struct audit_names;
    2518                 :            : struct filename {
    2519                 :            :         const char              *name;  /* pointer to actual string */
    2520                 :            :         const __user char       *uptr;  /* original userland pointer */
    2521                 :            :         int                     refcnt;
    2522                 :            :         struct audit_names      *aname;
    2523                 :            :         const char              iname[];
    2524                 :            : };
    2525                 :            : static_assert(offsetof(struct filename, iname) % sizeof(long) == 0);
    2526                 :            : 
    2527                 :            : extern long vfs_truncate(const struct path *, loff_t);
    2528                 :            : extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
    2529                 :            :                        struct file *filp);
    2530                 :            : extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
    2531                 :            :                         loff_t len);
    2532                 :            : extern long do_sys_open(int dfd, const char __user *filename, int flags,
    2533                 :            :                         umode_t mode);
    2534                 :            : extern struct file *file_open_name(struct filename *, int, umode_t);
    2535                 :            : extern struct file *filp_open(const char *, int, umode_t);
    2536                 :            : extern struct file *file_open_root(struct dentry *, struct vfsmount *,
    2537                 :            :                                    const char *, int, umode_t);
    2538                 :            : extern struct file * dentry_open(const struct path *, int, const struct cred *);
    2539                 :            : extern struct file * open_with_fake_path(const struct path *, int,
    2540                 :            :                                          struct inode*, const struct cred *);
    2541                 :            : static inline struct file *file_clone_open(struct file *file)
    2542                 :            : {
    2543                 :            :         return dentry_open(&file->f_path, file->f_flags, file->f_cred);
    2544                 :            : }
    2545                 :            : extern int filp_close(struct file *, fl_owner_t id);
    2546                 :            : 
    2547                 :            : extern struct filename *getname_flags(const char __user *, int, int *);
    2548                 :            : extern struct filename *getname(const char __user *);
    2549                 :            : extern struct filename *getname_kernel(const char *);
    2550                 :            : extern void putname(struct filename *name);
    2551                 :            : 
    2552                 :            : extern int finish_open(struct file *file, struct dentry *dentry,
    2553                 :            :                         int (*open)(struct inode *, struct file *));
    2554                 :            : extern int finish_no_open(struct file *file, struct dentry *dentry);
    2555                 :            : 
    2556                 :            : /* fs/ioctl.c */
    2557                 :            : 
    2558                 :            : extern int ioctl_preallocate(struct file *filp, void __user *argp);
    2559                 :            : 
    2560                 :            : /* fs/dcache.c */
    2561                 :            : extern void __init vfs_caches_init_early(void);
    2562                 :            : extern void __init vfs_caches_init(void);
    2563                 :            : 
    2564                 :            : extern struct kmem_cache *names_cachep;
    2565                 :            : 
    2566                 :            : #define __getname()             kmem_cache_alloc(names_cachep, GFP_KERNEL)
    2567                 :            : #define __putname(name)         kmem_cache_free(names_cachep, (void *)(name))
    2568                 :            : 
    2569                 :            : #ifdef CONFIG_BLOCK
    2570                 :            : extern int register_blkdev(unsigned int, const char *);
    2571                 :            : extern void unregister_blkdev(unsigned int, const char *);
    2572                 :            : extern void bdev_unhash_inode(dev_t dev);
    2573                 :            : extern struct block_device *bdget(dev_t);
    2574                 :            : extern struct block_device *bdgrab(struct block_device *bdev);
    2575                 :            : extern void bd_set_size(struct block_device *, loff_t size);
    2576                 :            : extern void bd_forget(struct inode *inode);
    2577                 :            : extern void bdput(struct block_device *);
    2578                 :            : extern void invalidate_bdev(struct block_device *);
    2579                 :            : extern void iterate_bdevs(void (*)(struct block_device *, void *), void *);
    2580                 :            : extern int sync_blockdev(struct block_device *bdev);
    2581                 :            : extern void kill_bdev(struct block_device *);
    2582                 :            : extern struct super_block *freeze_bdev(struct block_device *);
    2583                 :            : extern void emergency_thaw_all(void);
    2584                 :            : extern void emergency_thaw_bdev(struct super_block *sb);
    2585                 :            : extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
    2586                 :            : extern int fsync_bdev(struct block_device *);
    2587                 :            : 
    2588                 :            : extern struct super_block *blockdev_superblock;
    2589                 :            : 
    2590                 :            : static inline bool sb_is_blkdev_sb(struct super_block *sb)
    2591                 :            : {
    2592                 :          3 :         return sb == blockdev_superblock;
    2593                 :            : }
    2594                 :            : #else
    2595                 :            : static inline void bd_forget(struct inode *inode) {}
    2596                 :            : static inline int sync_blockdev(struct block_device *bdev) { return 0; }
    2597                 :            : static inline void kill_bdev(struct block_device *bdev) {}
    2598                 :            : static inline void invalidate_bdev(struct block_device *bdev) {}
    2599                 :            : 
    2600                 :            : static inline struct super_block *freeze_bdev(struct block_device *sb)
    2601                 :            : {
    2602                 :            :         return NULL;
    2603                 :            : }
    2604                 :            : 
    2605                 :            : static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
    2606                 :            : {
    2607                 :            :         return 0;
    2608                 :            : }
    2609                 :            : 
    2610                 :            : static inline int emergency_thaw_bdev(struct super_block *sb)
    2611                 :            : {
    2612                 :            :         return 0;
    2613                 :            : }
    2614                 :            : 
    2615                 :            : static inline void iterate_bdevs(void (*f)(struct block_device *, void *), void *arg)
    2616                 :            : {
    2617                 :            : }
    2618                 :            : 
    2619                 :            : static inline bool sb_is_blkdev_sb(struct super_block *sb)
    2620                 :            : {
    2621                 :            :         return false;
    2622                 :            : }
    2623                 :            : #endif
    2624                 :            : extern int sync_filesystem(struct super_block *);
    2625                 :            : extern const struct file_operations def_blk_fops;
    2626                 :            : extern const struct file_operations def_chr_fops;
    2627                 :            : #ifdef CONFIG_BLOCK
    2628                 :            : extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
    2629                 :            : extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
    2630                 :            : extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
    2631                 :            : extern int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder);
    2632                 :            : extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
    2633                 :            :                                                void *holder);
    2634                 :            : extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
    2635                 :            :                                               void *holder);
    2636                 :            : extern struct block_device *bd_start_claiming(struct block_device *bdev,
    2637                 :            :                                               void *holder);
    2638                 :            : extern void bd_finish_claiming(struct block_device *bdev,
    2639                 :            :                                struct block_device *whole, void *holder);
    2640                 :            : extern void bd_abort_claiming(struct block_device *bdev,
    2641                 :            :                               struct block_device *whole, void *holder);
    2642                 :            : extern void blkdev_put(struct block_device *bdev, fmode_t mode);
    2643                 :            : extern int __blkdev_reread_part(struct block_device *bdev);
    2644                 :            : extern int blkdev_reread_part(struct block_device *bdev);
    2645                 :            : 
    2646                 :            : #ifdef CONFIG_SYSFS
    2647                 :            : extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
    2648                 :            : extern void bd_unlink_disk_holder(struct block_device *bdev,
    2649                 :            :                                   struct gendisk *disk);
    2650                 :            : #else
    2651                 :            : static inline int bd_link_disk_holder(struct block_device *bdev,
    2652                 :            :                                       struct gendisk *disk)
    2653                 :            : {
    2654                 :            :         return 0;
    2655                 :            : }
    2656                 :            : static inline void bd_unlink_disk_holder(struct block_device *bdev,
    2657                 :            :                                          struct gendisk *disk)
    2658                 :            : {
    2659                 :            : }
    2660                 :            : #endif
    2661                 :            : #endif
    2662                 :            : 
    2663                 :            : /* fs/char_dev.c */
    2664                 :            : #define CHRDEV_MAJOR_MAX 512
    2665                 :            : /* Marks the bottom of the first segment of free char majors */
    2666                 :            : #define CHRDEV_MAJOR_DYN_END 234
    2667                 :            : /* Marks the top and bottom of the second segment of free char majors */
    2668                 :            : #define CHRDEV_MAJOR_DYN_EXT_START 511
    2669                 :            : #define CHRDEV_MAJOR_DYN_EXT_END 384
    2670                 :            : 
    2671                 :            : extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
    2672                 :            : extern int register_chrdev_region(dev_t, unsigned, const char *);
    2673                 :            : extern int __register_chrdev(unsigned int major, unsigned int baseminor,
    2674                 :            :                              unsigned int count, const char *name,
    2675                 :            :                              const struct file_operations *fops);
    2676                 :            : extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
    2677                 :            :                                 unsigned int count, const char *name);
    2678                 :            : extern void unregister_chrdev_region(dev_t, unsigned);
    2679                 :            : extern void chrdev_show(struct seq_file *,off_t);
    2680                 :            : 
    2681                 :            : static inline int register_chrdev(unsigned int major, const char *name,
    2682                 :            :                                   const struct file_operations *fops)
    2683                 :            : {
    2684                 :          3 :         return __register_chrdev(major, 0, 256, name, fops);
    2685                 :            : }
    2686                 :            : 
    2687                 :            : static inline void unregister_chrdev(unsigned int major, const char *name)
    2688                 :            : {
    2689                 :          0 :         __unregister_chrdev(major, 0, 256, name);
    2690                 :            : }
    2691                 :            : 
    2692                 :            : /* fs/block_dev.c */
    2693                 :            : #define BDEVNAME_SIZE   32      /* Largest string for a blockdev identifier */
    2694                 :            : #define BDEVT_SIZE      10      /* Largest string for MAJ:MIN for blkdev */
    2695                 :            : 
    2696                 :            : #ifdef CONFIG_BLOCK
    2697                 :            : #define BLKDEV_MAJOR_MAX        512
    2698                 :            : extern const char *__bdevname(dev_t, char *buffer);
    2699                 :            : extern const char *bdevname(struct block_device *bdev, char *buffer);
    2700                 :            : extern struct block_device *lookup_bdev(const char *);
    2701                 :            : extern void blkdev_show(struct seq_file *,off_t);
    2702                 :            : 
    2703                 :            : #else
    2704                 :            : #define BLKDEV_MAJOR_MAX        0
    2705                 :            : #endif
    2706                 :            : 
    2707                 :            : extern void init_special_inode(struct inode *, umode_t, dev_t);
    2708                 :            : 
    2709                 :            : /* Invalid inode operations -- fs/bad_inode.c */
    2710                 :            : extern void make_bad_inode(struct inode *);
    2711                 :            : extern bool is_bad_inode(struct inode *);
    2712                 :            : 
    2713                 :            : #ifdef CONFIG_BLOCK
    2714                 :            : extern void check_disk_size_change(struct gendisk *disk,
    2715                 :            :                 struct block_device *bdev, bool verbose);
    2716                 :            : extern int revalidate_disk(struct gendisk *);
    2717                 :            : extern int check_disk_change(struct block_device *);
    2718                 :            : extern int __invalidate_device(struct block_device *, bool);
    2719                 :            : extern int invalidate_partition(struct gendisk *, int);
    2720                 :            : #endif
    2721                 :            : unsigned long invalidate_mapping_pages(struct address_space *mapping,
    2722                 :            :                                         pgoff_t start, pgoff_t end);
    2723                 :            : 
    2724                 :            : static inline void invalidate_remote_inode(struct inode *inode)
    2725                 :            : {
    2726                 :            :         if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
    2727                 :            :             S_ISLNK(inode->i_mode))
    2728                 :            :                 invalidate_mapping_pages(inode->i_mapping, 0, -1);
    2729                 :            : }
    2730                 :            : extern int invalidate_inode_pages2(struct address_space *mapping);
    2731                 :            : extern int invalidate_inode_pages2_range(struct address_space *mapping,
    2732                 :            :                                          pgoff_t start, pgoff_t end);
    2733                 :            : extern int write_inode_now(struct inode *, int);
    2734                 :            : extern int filemap_fdatawrite(struct address_space *);
    2735                 :            : extern int filemap_flush(struct address_space *);
    2736                 :            : extern int filemap_fdatawait_keep_errors(struct address_space *mapping);
    2737                 :            : extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
    2738                 :            :                                    loff_t lend);
    2739                 :            : extern int filemap_fdatawait_range_keep_errors(struct address_space *mapping,
    2740                 :            :                 loff_t start_byte, loff_t end_byte);
    2741                 :            : 
    2742                 :          3 : static inline int filemap_fdatawait(struct address_space *mapping)
    2743                 :            : {
    2744                 :          3 :         return filemap_fdatawait_range(mapping, 0, LLONG_MAX);
    2745                 :            : }
    2746                 :            : 
    2747                 :            : extern bool filemap_range_has_page(struct address_space *, loff_t lstart,
    2748                 :            :                                   loff_t lend);
    2749                 :            : extern int filemap_write_and_wait(struct address_space *mapping);
    2750                 :            : extern int filemap_write_and_wait_range(struct address_space *mapping,
    2751                 :            :                                         loff_t lstart, loff_t lend);
    2752                 :            : extern int __filemap_fdatawrite_range(struct address_space *mapping,
    2753                 :            :                                 loff_t start, loff_t end, int sync_mode);
    2754                 :            : extern int filemap_fdatawrite_range(struct address_space *mapping,
    2755                 :            :                                 loff_t start, loff_t end);
    2756                 :            : extern int filemap_check_errors(struct address_space *mapping);
    2757                 :            : extern void __filemap_set_wb_err(struct address_space *mapping, int err);
    2758                 :            : 
    2759                 :            : extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
    2760                 :            :                                                 loff_t lend);
    2761                 :            : extern int __must_check file_check_and_advance_wb_err(struct file *file);
    2762                 :            : extern int __must_check file_write_and_wait_range(struct file *file,
    2763                 :            :                                                 loff_t start, loff_t end);
    2764                 :            : 
    2765                 :            : static inline int file_write_and_wait(struct file *file)
    2766                 :            : {
    2767                 :            :         return file_write_and_wait_range(file, 0, LLONG_MAX);
    2768                 :            : }
    2769                 :            : 
    2770                 :            : /**
    2771                 :            :  * filemap_set_wb_err - set a writeback error on an address_space
    2772                 :            :  * @mapping: mapping in which to set writeback error
    2773                 :            :  * @err: error to be set in mapping
    2774                 :            :  *
    2775                 :            :  * When writeback fails in some way, we must record that error so that
    2776                 :            :  * userspace can be informed when fsync and the like are called.  We endeavor
    2777                 :            :  * to report errors on any file that was open at the time of the error.  Some
    2778                 :            :  * internal callers also need to know when writeback errors have occurred.
    2779                 :            :  *
    2780                 :            :  * When a writeback error occurs, most filesystems will want to call
    2781                 :            :  * filemap_set_wb_err to record the error in the mapping so that it will be
    2782                 :            :  * automatically reported whenever fsync is called on the file.
    2783                 :            :  */
    2784                 :            : static inline void filemap_set_wb_err(struct address_space *mapping, int err)
    2785                 :            : {
    2786                 :            :         /* Fastpath for common case of no error */
    2787                 :          0 :         if (unlikely(err))
    2788                 :          0 :                 __filemap_set_wb_err(mapping, err);
    2789                 :            : }
    2790                 :            : 
    2791                 :            : /**
    2792                 :            :  * filemap_check_wb_error - has an error occurred since the mark was sampled?
    2793                 :            :  * @mapping: mapping to check for writeback errors
    2794                 :            :  * @since: previously-sampled errseq_t
    2795                 :            :  *
    2796                 :            :  * Grab the errseq_t value from the mapping, and see if it has changed "since"
    2797                 :            :  * the given value was sampled.
    2798                 :            :  *
    2799                 :            :  * If it has then report the latest error set, otherwise return 0.
    2800                 :            :  */
    2801                 :            : static inline int filemap_check_wb_err(struct address_space *mapping,
    2802                 :            :                                         errseq_t since)
    2803                 :            : {
    2804                 :          0 :         return errseq_check(&mapping->wb_err, since);
    2805                 :            : }
    2806                 :            : 
    2807                 :            : /**
    2808                 :            :  * filemap_sample_wb_err - sample the current errseq_t to test for later errors
    2809                 :            :  * @mapping: mapping to be sampled
    2810                 :            :  *
    2811                 :            :  * Writeback errors are always reported relative to a particular sample point
    2812                 :            :  * in the past. This function provides those sample points.
    2813                 :            :  */
    2814                 :            : static inline errseq_t filemap_sample_wb_err(struct address_space *mapping)
    2815                 :            : {
    2816                 :          3 :         return errseq_sample(&mapping->wb_err);
    2817                 :            : }
    2818                 :            : 
    2819                 :            : static inline int filemap_nr_thps(struct address_space *mapping)
    2820                 :            : {
    2821                 :            : #ifdef CONFIG_READ_ONLY_THP_FOR_FS
    2822                 :            :         return atomic_read(&mapping->nr_thps);
    2823                 :            : #else
    2824                 :            :         return 0;
    2825                 :            : #endif
    2826                 :            : }
    2827                 :            : 
    2828                 :            : static inline void filemap_nr_thps_inc(struct address_space *mapping)
    2829                 :            : {
    2830                 :            : #ifdef CONFIG_READ_ONLY_THP_FOR_FS
    2831                 :            :         atomic_inc(&mapping->nr_thps);
    2832                 :            : #else
    2833                 :            :         WARN_ON_ONCE(1);
    2834                 :            : #endif
    2835                 :            : }
    2836                 :            : 
    2837                 :            : static inline void filemap_nr_thps_dec(struct address_space *mapping)
    2838                 :            : {
    2839                 :            : #ifdef CONFIG_READ_ONLY_THP_FOR_FS
    2840                 :            :         atomic_dec(&mapping->nr_thps);
    2841                 :            : #else
    2842                 :            :         WARN_ON_ONCE(1);
    2843                 :            : #endif
    2844                 :            : }
    2845                 :            : 
    2846                 :            : extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
    2847                 :            :                            int datasync);
    2848                 :            : extern int vfs_fsync(struct file *file, int datasync);
    2849                 :            : 
    2850                 :            : extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
    2851                 :            :                                 unsigned int flags);
    2852                 :            : 
    2853                 :            : /*
    2854                 :            :  * Sync the bytes written if this was a synchronous write.  Expect ki_pos
    2855                 :            :  * to already be updated for the write, and will return either the amount
    2856                 :            :  * of bytes passed in, or an error if syncing the file failed.
    2857                 :            :  */
    2858                 :          3 : static inline ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count)
    2859                 :            : {
    2860                 :          3 :         if (iocb->ki_flags & IOCB_DSYNC) {
    2861                 :          0 :                 int ret = vfs_fsync_range(iocb->ki_filp,
    2862                 :          0 :                                 iocb->ki_pos - count, iocb->ki_pos - 1,
    2863                 :          0 :                                 (iocb->ki_flags & IOCB_SYNC) ? 0 : 1);
    2864                 :          0 :                 if (ret)
    2865                 :            :                         return ret;
    2866                 :            :         }
    2867                 :            : 
    2868                 :          3 :         return count;
    2869                 :            : }
    2870                 :            : 
    2871                 :            : extern void emergency_sync(void);
    2872                 :            : extern void emergency_remount(void);
    2873                 :            : #ifdef CONFIG_BLOCK
    2874                 :            : extern sector_t bmap(struct inode *, sector_t);
    2875                 :            : #endif
    2876                 :            : extern int notify_change(struct dentry *, struct iattr *, struct inode **);
    2877                 :            : extern int inode_permission(struct inode *, int);
    2878                 :            : extern int generic_permission(struct inode *, int);
    2879                 :            : extern int __check_sticky(struct inode *dir, struct inode *inode);
    2880                 :            : 
    2881                 :            : static inline bool execute_ok(struct inode *inode)
    2882                 :            : {
    2883                 :          0 :         return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
    2884                 :            : }
    2885                 :            : 
    2886                 :          3 : static inline void file_start_write(struct file *file)
    2887                 :            : {
    2888                 :          3 :         if (!S_ISREG(file_inode(file)->i_mode))
    2889                 :          3 :                 return;
    2890                 :          3 :         __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, true);
    2891                 :            : }
    2892                 :            : 
    2893                 :          0 : static inline bool file_start_write_trylock(struct file *file)
    2894                 :            : {
    2895                 :          0 :         if (!S_ISREG(file_inode(file)->i_mode))
    2896                 :            :                 return true;
    2897                 :          0 :         return __sb_start_write(file_inode(file)->i_sb, SB_FREEZE_WRITE, false);
    2898                 :            : }
    2899                 :            : 
    2900                 :          3 : static inline void file_end_write(struct file *file)
    2901                 :            : {
    2902                 :          3 :         if (!S_ISREG(file_inode(file)->i_mode))
    2903                 :          3 :                 return;
    2904                 :          3 :         __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
    2905                 :            : }
    2906                 :            : 
    2907                 :            : /*
    2908                 :            :  * get_write_access() gets write permission for a file.
    2909                 :            :  * put_write_access() releases this write permission.
    2910                 :            :  * This is used for regular files.
    2911                 :            :  * We cannot support write (and maybe mmap read-write shared) accesses and
    2912                 :            :  * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
    2913                 :            :  * can have the following values:
    2914                 :            :  * 0: no writers, no VM_DENYWRITE mappings
    2915                 :            :  * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
    2916                 :            :  * > 0: (i_writecount) users are writing to the file.
    2917                 :            :  *
    2918                 :            :  * Normally we operate on that counter with atomic_{inc,dec} and it's safe
    2919                 :            :  * except for the cases where we don't hold i_writecount yet. Then we need to
    2920                 :            :  * use {get,deny}_write_access() - these functions check the sign and refuse
    2921                 :            :  * to do the change if sign is wrong.
    2922                 :            :  */
    2923                 :            : static inline int get_write_access(struct inode *inode)
    2924                 :            : {
    2925                 :          3 :         return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
    2926                 :            : }
    2927                 :            : static inline int deny_write_access(struct file *file)
    2928                 :            : {
    2929                 :            :         struct inode *inode = file_inode(file);
    2930                 :          3 :         return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
    2931                 :            : }
    2932                 :            : static inline void put_write_access(struct inode * inode)
    2933                 :            : {
    2934                 :          3 :         atomic_dec(&inode->i_writecount);
    2935                 :            : }
    2936                 :          3 : static inline void allow_write_access(struct file *file)
    2937                 :            : {
    2938                 :          3 :         if (file)
    2939                 :          3 :                 atomic_inc(&file_inode(file)->i_writecount);
    2940                 :          3 : }
    2941                 :            : static inline bool inode_is_open_for_write(const struct inode *inode)
    2942                 :            : {
    2943                 :          3 :         return atomic_read(&inode->i_writecount) > 0;
    2944                 :            : }
    2945                 :            : 
    2946                 :            : #if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
    2947                 :          3 : static inline void i_readcount_dec(struct inode *inode)
    2948                 :            : {
    2949                 :          3 :         BUG_ON(!atomic_read(&inode->i_readcount));
    2950                 :          3 :         atomic_dec(&inode->i_readcount);
    2951                 :          3 : }
    2952                 :            : static inline void i_readcount_inc(struct inode *inode)
    2953                 :            : {
    2954                 :          3 :         atomic_inc(&inode->i_readcount);
    2955                 :            : }
    2956                 :            : #else
    2957                 :            : static inline void i_readcount_dec(struct inode *inode)
    2958                 :            : {
    2959                 :            :         return;
    2960                 :            : }
    2961                 :            : static inline void i_readcount_inc(struct inode *inode)
    2962                 :            : {
    2963                 :            :         return;
    2964                 :            : }
    2965                 :            : #endif
    2966                 :            : extern int do_pipe_flags(int *, int);
    2967                 :            : 
    2968                 :            : #define __kernel_read_file_id(id) \
    2969                 :            :         id(UNKNOWN, unknown)            \
    2970                 :            :         id(FIRMWARE, firmware)          \
    2971                 :            :         id(FIRMWARE_PREALLOC_BUFFER, firmware)  \
    2972                 :            :         id(MODULE, kernel-module)               \
    2973                 :            :         id(KEXEC_IMAGE, kexec-image)            \
    2974                 :            :         id(KEXEC_INITRAMFS, kexec-initramfs)    \
    2975                 :            :         id(POLICY, security-policy)             \
    2976                 :            :         id(X509_CERTIFICATE, x509-certificate)  \
    2977                 :            :         id(MAX_ID, )
    2978                 :            : 
    2979                 :            : #define __fid_enumify(ENUM, dummy) READING_ ## ENUM,
    2980                 :            : #define __fid_stringify(dummy, str) #str,
    2981                 :            : 
    2982                 :            : enum kernel_read_file_id {
    2983                 :            :         __kernel_read_file_id(__fid_enumify)
    2984                 :            : };
    2985                 :            : 
    2986                 :            : static const char * const kernel_read_file_str[] = {
    2987                 :            :         __kernel_read_file_id(__fid_stringify)
    2988                 :            : };
    2989                 :            : 
    2990                 :            : static inline const char *kernel_read_file_id_str(enum kernel_read_file_id id)
    2991                 :            : {
    2992                 :            :         if ((unsigned)id >= READING_MAX_ID)
    2993                 :            :                 return kernel_read_file_str[READING_UNKNOWN];
    2994                 :            : 
    2995                 :            :         return kernel_read_file_str[id];
    2996                 :            : }
    2997                 :            : 
    2998                 :            : extern int kernel_read_file(struct file *, void **, loff_t *, loff_t,
    2999                 :            :                             enum kernel_read_file_id);
    3000                 :            : extern int kernel_read_file_from_path(const char *, void **, loff_t *, loff_t,
    3001                 :            :                                       enum kernel_read_file_id);
    3002                 :            : extern int kernel_read_file_from_fd(int, void **, loff_t *, loff_t,
    3003                 :            :                                     enum kernel_read_file_id);
    3004                 :            : extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *);
    3005                 :            : extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *);
    3006                 :            : extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *);
    3007                 :            : extern struct file * open_exec(const char *);
    3008                 :            :  
    3009                 :            : /* fs/dcache.c -- generic fs support functions */
    3010                 :            : extern bool is_subdir(struct dentry *, struct dentry *);
    3011                 :            : extern bool path_is_under(const struct path *, const struct path *);
    3012                 :            : 
    3013                 :            : extern char *file_path(struct file *, char *, int);
    3014                 :            : 
    3015                 :            : #include <linux/err.h>
    3016                 :            : 
    3017                 :            : /* needed for stackable file system support */
    3018                 :            : extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
    3019                 :            : 
    3020                 :            : extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
    3021                 :            : 
    3022                 :            : extern int inode_init_always(struct super_block *, struct inode *);
    3023                 :            : extern void inode_init_once(struct inode *);
    3024                 :            : extern void address_space_init_once(struct address_space *mapping);
    3025                 :            : extern struct inode * igrab(struct inode *);
    3026                 :            : extern ino_t iunique(struct super_block *, ino_t);
    3027                 :            : extern int inode_needs_sync(struct inode *inode);
    3028                 :            : extern int generic_delete_inode(struct inode *inode);
    3029                 :            : static inline int generic_drop_inode(struct inode *inode)
    3030                 :            : {
    3031                 :          3 :         return !inode->i_nlink || inode_unhashed(inode);
    3032                 :            : }
    3033                 :            : 
    3034                 :            : extern struct inode *ilookup5_nowait(struct super_block *sb,
    3035                 :            :                 unsigned long hashval, int (*test)(struct inode *, void *),
    3036                 :            :                 void *data);
    3037                 :            : extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
    3038                 :            :                 int (*test)(struct inode *, void *), void *data);
    3039                 :            : extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
    3040                 :            : 
    3041                 :            : extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
    3042                 :            :                 int (*test)(struct inode *, void *),
    3043                 :            :                 int (*set)(struct inode *, void *),
    3044                 :            :                 void *data);
    3045                 :            : extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
    3046                 :            : extern struct inode * iget_locked(struct super_block *, unsigned long);
    3047                 :            : extern struct inode *find_inode_nowait(struct super_block *,
    3048                 :            :                                        unsigned long,
    3049                 :            :                                        int (*match)(struct inode *,
    3050                 :            :                                                     unsigned long, void *),
    3051                 :            :                                        void *data);
    3052                 :            : extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
    3053                 :            : extern int insert_inode_locked(struct inode *);
    3054                 :            : #ifdef CONFIG_DEBUG_LOCK_ALLOC
    3055                 :            : extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
    3056                 :            : #else
    3057                 :            : static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
    3058                 :            : #endif
    3059                 :            : extern void unlock_new_inode(struct inode *);
    3060                 :            : extern void discard_new_inode(struct inode *);
    3061                 :            : extern unsigned int get_next_ino(void);
    3062                 :            : extern void evict_inodes(struct super_block *sb);
    3063                 :            : 
    3064                 :            : extern void __iget(struct inode * inode);
    3065                 :            : extern void iget_failed(struct inode *);
    3066                 :            : extern void clear_inode(struct inode *);
    3067                 :            : extern void __destroy_inode(struct inode *);
    3068                 :            : extern struct inode *new_inode_pseudo(struct super_block *sb);
    3069                 :            : extern struct inode *new_inode(struct super_block *sb);
    3070                 :            : extern void free_inode_nonrcu(struct inode *inode);
    3071                 :            : extern int should_remove_suid(struct dentry *);
    3072                 :            : extern int file_remove_privs(struct file *);
    3073                 :            : 
    3074                 :            : extern void __insert_inode_hash(struct inode *, unsigned long hashval);
    3075                 :            : static inline void insert_inode_hash(struct inode *inode)
    3076                 :            : {
    3077                 :          3 :         __insert_inode_hash(inode, inode->i_ino);
    3078                 :            : }
    3079                 :            : 
    3080                 :            : extern void __remove_inode_hash(struct inode *);
    3081                 :            : static inline void remove_inode_hash(struct inode *inode)
    3082                 :            : {
    3083                 :          3 :         if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash))
    3084                 :          3 :                 __remove_inode_hash(inode);
    3085                 :            : }
    3086                 :            : 
    3087                 :            : extern void inode_sb_list_add(struct inode *inode);
    3088                 :            : 
    3089                 :            : #ifdef CONFIG_BLOCK
    3090                 :            : extern int bdev_read_only(struct block_device *);
    3091                 :            : #endif
    3092                 :            : extern int set_blocksize(struct block_device *, int);
    3093                 :            : extern int sb_set_blocksize(struct super_block *, int);
    3094                 :            : extern int sb_min_blocksize(struct super_block *, int);
    3095                 :            : 
    3096                 :            : extern int generic_file_mmap(struct file *, struct vm_area_struct *);
    3097                 :            : extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
    3098                 :            : extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
    3099                 :            : extern int generic_remap_checks(struct file *file_in, loff_t pos_in,
    3100                 :            :                                 struct file *file_out, loff_t pos_out,
    3101                 :            :                                 loff_t *count, unsigned int remap_flags);
    3102                 :            : extern int generic_file_rw_checks(struct file *file_in, struct file *file_out);
    3103                 :            : extern int generic_copy_file_checks(struct file *file_in, loff_t pos_in,
    3104                 :            :                                     struct file *file_out, loff_t pos_out,
    3105                 :            :                                     size_t *count, unsigned int flags);
    3106                 :            : extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
    3107                 :            : extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
    3108                 :            : extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
    3109                 :            : extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
    3110                 :            : extern ssize_t generic_perform_write(struct file *, struct iov_iter *, loff_t);
    3111                 :            : 
    3112                 :            : ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
    3113                 :            :                 rwf_t flags);
    3114                 :            : ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
    3115                 :            :                 rwf_t flags);
    3116                 :            : 
    3117                 :            : /* fs/block_dev.c */
    3118                 :            : extern ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to);
    3119                 :            : extern ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from);
    3120                 :            : extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
    3121                 :            :                         int datasync);
    3122                 :            : extern void block_sync_page(struct page *page);
    3123                 :            : 
    3124                 :            : /* fs/splice.c */
    3125                 :            : extern ssize_t generic_file_splice_read(struct file *, loff_t *,
    3126                 :            :                 struct pipe_inode_info *, size_t, unsigned int);
    3127                 :            : extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
    3128                 :            :                 struct file *, loff_t *, size_t, unsigned int);
    3129                 :            : extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
    3130                 :            :                 struct file *out, loff_t *, size_t len, unsigned int flags);
    3131                 :            : extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
    3132                 :            :                 loff_t *opos, size_t len, unsigned int flags);
    3133                 :            : 
    3134                 :            : 
    3135                 :            : extern void
    3136                 :            : file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
    3137                 :            : extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
    3138                 :            : extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
    3139                 :            : extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
    3140                 :            : extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
    3141                 :            : extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
    3142                 :            :                 int whence, loff_t maxsize, loff_t eof);
    3143                 :            : extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
    3144                 :            :                 int whence, loff_t size);
    3145                 :            : extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
    3146                 :            : extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
    3147                 :            : extern int generic_file_open(struct inode * inode, struct file * filp);
    3148                 :            : extern int nonseekable_open(struct inode * inode, struct file * filp);
    3149                 :            : extern int stream_open(struct inode * inode, struct file * filp);
    3150                 :            : 
    3151                 :            : #ifdef CONFIG_BLOCK
    3152                 :            : typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
    3153                 :            :                             loff_t file_offset);
    3154                 :            : 
    3155                 :            : enum {
    3156                 :            :         /* need locking between buffered and direct access */
    3157                 :            :         DIO_LOCKING     = 0x01,
    3158                 :            : 
    3159                 :            :         /* filesystem does not support filling holes */
    3160                 :            :         DIO_SKIP_HOLES  = 0x02,
    3161                 :            : };
    3162                 :            : 
    3163                 :            : void dio_end_io(struct bio *bio);
    3164                 :            : void dio_warn_stale_pagecache(struct file *filp);
    3165                 :            : 
    3166                 :            : ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
    3167                 :            :                              struct block_device *bdev, struct iov_iter *iter,
    3168                 :            :                              get_block_t get_block,
    3169                 :            :                              dio_iodone_t end_io, dio_submit_t submit_io,
    3170                 :            :                              int flags);
    3171                 :            : 
    3172                 :          0 : static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
    3173                 :            :                                          struct inode *inode,
    3174                 :            :                                          struct iov_iter *iter,
    3175                 :            :                                          get_block_t get_block)
    3176                 :            : {
    3177                 :          0 :         return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
    3178                 :            :                         get_block, NULL, NULL, DIO_LOCKING | DIO_SKIP_HOLES);
    3179                 :            : }
    3180                 :            : #endif
    3181                 :            : 
    3182                 :            : void inode_dio_wait(struct inode *inode);
    3183                 :            : 
    3184                 :            : /*
    3185                 :            :  * inode_dio_begin - signal start of a direct I/O requests
    3186                 :            :  * @inode: inode the direct I/O happens on
    3187                 :            :  *
    3188                 :            :  * This is called once we've finished processing a direct I/O request,
    3189                 :            :  * and is used to wake up callers waiting for direct I/O to be quiesced.
    3190                 :            :  */
    3191                 :            : static inline void inode_dio_begin(struct inode *inode)
    3192                 :            : {
    3193                 :          0 :         atomic_inc(&inode->i_dio_count);
    3194                 :            : }
    3195                 :            : 
    3196                 :            : /*
    3197                 :            :  * inode_dio_end - signal finish of a direct I/O requests
    3198                 :            :  * @inode: inode the direct I/O happens on
    3199                 :            :  *
    3200                 :            :  * This is called once we've finished processing a direct I/O request,
    3201                 :            :  * and is used to wake up callers waiting for direct I/O to be quiesced.
    3202                 :            :  */
    3203                 :          0 : static inline void inode_dio_end(struct inode *inode)
    3204                 :            : {
    3205                 :          0 :         if (atomic_dec_and_test(&inode->i_dio_count))
    3206                 :          0 :                 wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
    3207                 :          0 : }
    3208                 :            : 
    3209                 :            : extern void inode_set_flags(struct inode *inode, unsigned int flags,
    3210                 :            :                             unsigned int mask);
    3211                 :            : 
    3212                 :            : extern const struct file_operations generic_ro_fops;
    3213                 :            : 
    3214                 :            : #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
    3215                 :            : 
    3216                 :            : extern int readlink_copy(char __user *, int, const char *);
    3217                 :            : extern int page_readlink(struct dentry *, char __user *, int);
    3218                 :            : extern const char *page_get_link(struct dentry *, struct inode *,
    3219                 :            :                                  struct delayed_call *);
    3220                 :            : extern void page_put_link(void *);
    3221                 :            : extern int __page_symlink(struct inode *inode, const char *symname, int len,
    3222                 :            :                 int nofs);
    3223                 :            : extern int page_symlink(struct inode *inode, const char *symname, int len);
    3224                 :            : extern const struct inode_operations page_symlink_inode_operations;
    3225                 :            : extern void kfree_link(void *);
    3226                 :            : extern void generic_fillattr(struct inode *, struct kstat *);
    3227                 :            : extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
    3228                 :            : extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
    3229                 :            : void __inode_add_bytes(struct inode *inode, loff_t bytes);
    3230                 :            : void inode_add_bytes(struct inode *inode, loff_t bytes);
    3231                 :            : void __inode_sub_bytes(struct inode *inode, loff_t bytes);
    3232                 :            : void inode_sub_bytes(struct inode *inode, loff_t bytes);
    3233                 :            : static inline loff_t __inode_get_bytes(struct inode *inode)
    3234                 :            : {
    3235                 :          0 :         return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
    3236                 :            : }
    3237                 :            : loff_t inode_get_bytes(struct inode *inode);
    3238                 :            : void inode_set_bytes(struct inode *inode, loff_t bytes);
    3239                 :            : const char *simple_get_link(struct dentry *, struct inode *,
    3240                 :            :                             struct delayed_call *);
    3241                 :            : extern const struct inode_operations simple_symlink_inode_operations;
    3242                 :            : 
    3243                 :            : extern int iterate_dir(struct file *, struct dir_context *);
    3244                 :            : 
    3245                 :            : extern int vfs_statx(int, const char __user *, int, struct kstat *, u32);
    3246                 :            : extern int vfs_statx_fd(unsigned int, struct kstat *, u32, unsigned int);
    3247                 :            : 
    3248                 :            : static inline int vfs_stat(const char __user *filename, struct kstat *stat)
    3249                 :            : {
    3250                 :          3 :         return vfs_statx(AT_FDCWD, filename, AT_NO_AUTOMOUNT,
    3251                 :            :                          stat, STATX_BASIC_STATS);
    3252                 :            : }
    3253                 :            : static inline int vfs_lstat(const char __user *name, struct kstat *stat)
    3254                 :            : {
    3255                 :          3 :         return vfs_statx(AT_FDCWD, name, AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT,
    3256                 :            :                          stat, STATX_BASIC_STATS);
    3257                 :            : }
    3258                 :            : static inline int vfs_fstatat(int dfd, const char __user *filename,
    3259                 :            :                               struct kstat *stat, int flags)
    3260                 :            : {
    3261                 :          3 :         return vfs_statx(dfd, filename, flags | AT_NO_AUTOMOUNT,
    3262                 :            :                          stat, STATX_BASIC_STATS);
    3263                 :            : }
    3264                 :            : static inline int vfs_fstat(int fd, struct kstat *stat)
    3265                 :            : {
    3266                 :          3 :         return vfs_statx_fd(fd, stat, STATX_BASIC_STATS, 0);
    3267                 :            : }
    3268                 :            : 
    3269                 :            : 
    3270                 :            : extern const char *vfs_get_link(struct dentry *, struct delayed_call *);
    3271                 :            : extern int vfs_readlink(struct dentry *, char __user *, int);
    3272                 :            : 
    3273                 :            : extern int __generic_block_fiemap(struct inode *inode,
    3274                 :            :                                   struct fiemap_extent_info *fieinfo,
    3275                 :            :                                   loff_t start, loff_t len,
    3276                 :            :                                   get_block_t *get_block);
    3277                 :            : extern int generic_block_fiemap(struct inode *inode,
    3278                 :            :                                 struct fiemap_extent_info *fieinfo, u64 start,
    3279                 :            :                                 u64 len, get_block_t *get_block);
    3280                 :            : 
    3281                 :            : extern struct file_system_type *get_filesystem(struct file_system_type *fs);
    3282                 :            : extern void put_filesystem(struct file_system_type *fs);
    3283                 :            : extern struct file_system_type *get_fs_type(const char *name);
    3284                 :            : extern struct super_block *get_super(struct block_device *);
    3285                 :            : extern struct super_block *get_super_thawed(struct block_device *);
    3286                 :            : extern struct super_block *get_super_exclusive_thawed(struct block_device *bdev);
    3287                 :            : extern struct super_block *get_active_super(struct block_device *bdev);
    3288                 :            : extern void drop_super(struct super_block *sb);
    3289                 :            : extern void drop_super_exclusive(struct super_block *sb);
    3290                 :            : extern void iterate_supers(void (*)(struct super_block *, void *), void *);
    3291                 :            : extern void iterate_supers_type(struct file_system_type *,
    3292                 :            :                                 void (*)(struct super_block *, void *), void *);
    3293                 :            : 
    3294                 :            : extern int dcache_dir_open(struct inode *, struct file *);
    3295                 :            : extern int dcache_dir_close(struct inode *, struct file *);
    3296                 :            : extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
    3297                 :            : extern int dcache_readdir(struct file *, struct dir_context *);
    3298                 :            : extern int simple_setattr(struct dentry *, struct iattr *);
    3299                 :            : extern int simple_getattr(const struct path *, struct kstat *, u32, unsigned int);
    3300                 :            : extern int simple_statfs(struct dentry *, struct kstatfs *);
    3301                 :            : extern int simple_open(struct inode *inode, struct file *file);
    3302                 :            : extern int simple_link(struct dentry *, struct inode *, struct dentry *);
    3303                 :            : extern int simple_unlink(struct inode *, struct dentry *);
    3304                 :            : extern int simple_rmdir(struct inode *, struct dentry *);
    3305                 :            : extern int simple_rename(struct inode *, struct dentry *,
    3306                 :            :                          struct inode *, struct dentry *, unsigned int);
    3307                 :            : extern int noop_fsync(struct file *, loff_t, loff_t, int);
    3308                 :            : extern int noop_set_page_dirty(struct page *page);
    3309                 :            : extern void noop_invalidatepage(struct page *page, unsigned int offset,
    3310                 :            :                 unsigned int length);
    3311                 :            : extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
    3312                 :            : extern int simple_empty(struct dentry *);
    3313                 :            : extern int simple_readpage(struct file *file, struct page *page);
    3314                 :            : extern int simple_write_begin(struct file *file, struct address_space *mapping,
    3315                 :            :                         loff_t pos, unsigned len, unsigned flags,
    3316                 :            :                         struct page **pagep, void **fsdata);
    3317                 :            : extern int simple_write_end(struct file *file, struct address_space *mapping,
    3318                 :            :                         loff_t pos, unsigned len, unsigned copied,
    3319                 :            :                         struct page *page, void *fsdata);
    3320                 :            : extern int always_delete_dentry(const struct dentry *);
    3321                 :            : extern struct inode *alloc_anon_inode(struct super_block *);
    3322                 :            : extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
    3323                 :            : extern const struct dentry_operations simple_dentry_operations;
    3324                 :            : 
    3325                 :            : extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
    3326                 :            : extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
    3327                 :            : extern const struct file_operations simple_dir_operations;
    3328                 :            : extern const struct inode_operations simple_dir_inode_operations;
    3329                 :            : extern void make_empty_dir_inode(struct inode *inode);
    3330                 :            : extern bool is_empty_dir_inode(struct inode *inode);
    3331                 :            : struct tree_descr { const char *name; const struct file_operations *ops; int mode; };
    3332                 :            : struct dentry *d_alloc_name(struct dentry *, const char *);
    3333                 :            : extern int simple_fill_super(struct super_block *, unsigned long,
    3334                 :            :                              const struct tree_descr *);
    3335                 :            : extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
    3336                 :            : extern void simple_release_fs(struct vfsmount **mount, int *count);
    3337                 :            : 
    3338                 :            : extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
    3339                 :            :                         loff_t *ppos, const void *from, size_t available);
    3340                 :            : extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
    3341                 :            :                 const void __user *from, size_t count);
    3342                 :            : 
    3343                 :            : extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
    3344                 :            : extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
    3345                 :            : 
    3346                 :            : extern int generic_check_addressable(unsigned, u64);
    3347                 :            : 
    3348                 :            : #ifdef CONFIG_MIGRATION
    3349                 :            : extern int buffer_migrate_page(struct address_space *,
    3350                 :            :                                 struct page *, struct page *,
    3351                 :            :                                 enum migrate_mode);
    3352                 :            : extern int buffer_migrate_page_norefs(struct address_space *,
    3353                 :            :                                 struct page *, struct page *,
    3354                 :            :                                 enum migrate_mode);
    3355                 :            : #else
    3356                 :            : #define buffer_migrate_page NULL
    3357                 :            : #define buffer_migrate_page_norefs NULL
    3358                 :            : #endif
    3359                 :            : 
    3360                 :            : extern int setattr_prepare(struct dentry *, struct iattr *);
    3361                 :            : extern int inode_newsize_ok(const struct inode *, loff_t offset);
    3362                 :            : extern void setattr_copy(struct inode *inode, const struct iattr *attr);
    3363                 :            : 
    3364                 :            : extern int file_update_time(struct file *file);
    3365                 :            : 
    3366                 :            : static inline bool io_is_direct(struct file *filp)
    3367                 :            : {
    3368                 :          3 :         return (filp->f_flags & O_DIRECT) || IS_DAX(filp->f_mapping->host);
    3369                 :            : }
    3370                 :            : 
    3371                 :            : static inline bool vma_is_dax(struct vm_area_struct *vma)
    3372                 :            : {
    3373                 :            :         return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host);
    3374                 :            : }
    3375                 :            : 
    3376                 :            : static inline bool vma_is_fsdax(struct vm_area_struct *vma)
    3377                 :            : {
    3378                 :            :         struct inode *inode;
    3379                 :            : 
    3380                 :            :         if (!vma->vm_file)
    3381                 :            :                 return false;
    3382                 :            :         if (!vma_is_dax(vma))
    3383                 :            :                 return false;
    3384                 :            :         inode = file_inode(vma->vm_file);
    3385                 :            :         if (S_ISCHR(inode->i_mode))
    3386                 :            :                 return false; /* device-dax */
    3387                 :            :         return true;
    3388                 :            : }
    3389                 :            : 
    3390                 :          3 : static inline int iocb_flags(struct file *file)
    3391                 :            : {
    3392                 :            :         int res = 0;
    3393                 :          3 :         if (file->f_flags & O_APPEND)
    3394                 :            :                 res |= IOCB_APPEND;
    3395                 :          3 :         if (io_is_direct(file))
    3396                 :          0 :                 res |= IOCB_DIRECT;
    3397                 :          3 :         if ((file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host))
    3398                 :          0 :                 res |= IOCB_DSYNC;
    3399                 :          3 :         if (file->f_flags & __O_SYNC)
    3400                 :          0 :                 res |= IOCB_SYNC;
    3401                 :          3 :         return res;
    3402                 :            : }
    3403                 :            : 
    3404                 :          3 : static inline int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags)
    3405                 :            : {
    3406                 :          3 :         if (unlikely(flags & ~RWF_SUPPORTED))
    3407                 :            :                 return -EOPNOTSUPP;
    3408                 :            : 
    3409                 :          3 :         if (flags & RWF_NOWAIT) {
    3410                 :          0 :                 if (!(ki->ki_filp->f_mode & FMODE_NOWAIT))
    3411                 :            :                         return -EOPNOTSUPP;
    3412                 :          0 :                 ki->ki_flags |= IOCB_NOWAIT;
    3413                 :            :         }
    3414                 :          3 :         if (flags & RWF_HIPRI)
    3415                 :          0 :                 ki->ki_flags |= IOCB_HIPRI;
    3416                 :          3 :         if (flags & RWF_DSYNC)
    3417                 :          0 :                 ki->ki_flags |= IOCB_DSYNC;
    3418                 :          3 :         if (flags & RWF_SYNC)
    3419                 :          0 :                 ki->ki_flags |= (IOCB_DSYNC | IOCB_SYNC);
    3420                 :          3 :         if (flags & RWF_APPEND)
    3421                 :          0 :                 ki->ki_flags |= IOCB_APPEND;
    3422                 :            :         return 0;
    3423                 :            : }
    3424                 :            : 
    3425                 :          3 : static inline ino_t parent_ino(struct dentry *dentry)
    3426                 :            : {
    3427                 :            :         ino_t res;
    3428                 :            : 
    3429                 :            :         /*
    3430                 :            :          * Don't strictly need d_lock here? If the parent ino could change
    3431                 :            :          * then surely we'd have a deeper race in the caller?
    3432                 :            :          */
    3433                 :            :         spin_lock(&dentry->d_lock);
    3434                 :          3 :         res = dentry->d_parent->d_inode->i_ino;
    3435                 :            :         spin_unlock(&dentry->d_lock);
    3436                 :          3 :         return res;
    3437                 :            : }
    3438                 :            : 
    3439                 :            : /* Transaction based IO helpers */
    3440                 :            : 
    3441                 :            : /*
    3442                 :            :  * An argresp is stored in an allocated page and holds the
    3443                 :            :  * size of the argument or response, along with its content
    3444                 :            :  */
    3445                 :            : struct simple_transaction_argresp {
    3446                 :            :         ssize_t size;
    3447                 :            :         char data[0];
    3448                 :            : };
    3449                 :            : 
    3450                 :            : #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
    3451                 :            : 
    3452                 :            : char *simple_transaction_get(struct file *file, const char __user *buf,
    3453                 :            :                                 size_t size);
    3454                 :            : ssize_t simple_transaction_read(struct file *file, char __user *buf,
    3455                 :            :                                 size_t size, loff_t *pos);
    3456                 :            : int simple_transaction_release(struct inode *inode, struct file *file);
    3457                 :            : 
    3458                 :            : void simple_transaction_set(struct file *file, size_t n);
    3459                 :            : 
    3460                 :            : /*
    3461                 :            :  * simple attribute files
    3462                 :            :  *
    3463                 :            :  * These attributes behave similar to those in sysfs:
    3464                 :            :  *
    3465                 :            :  * Writing to an attribute immediately sets a value, an open file can be
    3466                 :            :  * written to multiple times.
    3467                 :            :  *
    3468                 :            :  * Reading from an attribute creates a buffer from the value that might get
    3469                 :            :  * read with multiple read calls. When the attribute has been read
    3470                 :            :  * completely, no further read calls are possible until the file is opened
    3471                 :            :  * again.
    3472                 :            :  *
    3473                 :            :  * All attributes contain a text representation of a numeric value
    3474                 :            :  * that are accessed with the get() and set() functions.
    3475                 :            :  */
    3476                 :            : #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)            \
    3477                 :            : static int __fops ## _open(struct inode *inode, struct file *file)      \
    3478                 :            : {                                                                       \
    3479                 :            :         __simple_attr_check_format(__fmt, 0ull);                        \
    3480                 :            :         return simple_attr_open(inode, file, __get, __set, __fmt);      \
    3481                 :            : }                                                                       \
    3482                 :            : static const struct file_operations __fops = {                          \
    3483                 :            :         .owner   = THIS_MODULE,                                         \
    3484                 :            :         .open    = __fops ## _open,                                     \
    3485                 :            :         .release = simple_attr_release,                                 \
    3486                 :            :         .read    = simple_attr_read,                                    \
    3487                 :            :         .write   = simple_attr_write,                                   \
    3488                 :            :         .llseek  = generic_file_llseek,                                 \
    3489                 :            : }
    3490                 :            : 
    3491                 :            : static inline __printf(1, 2)
    3492                 :            : void __simple_attr_check_format(const char *fmt, ...)
    3493                 :            : {
    3494                 :            :         /* don't do anything, just let the compiler check the arguments; */
    3495                 :            : }
    3496                 :            : 
    3497                 :            : int simple_attr_open(struct inode *inode, struct file *file,
    3498                 :            :                      int (*get)(void *, u64 *), int (*set)(void *, u64),
    3499                 :            :                      const char *fmt);
    3500                 :            : int simple_attr_release(struct inode *inode, struct file *file);
    3501                 :            : ssize_t simple_attr_read(struct file *file, char __user *buf,
    3502                 :            :                          size_t len, loff_t *ppos);
    3503                 :            : ssize_t simple_attr_write(struct file *file, const char __user *buf,
    3504                 :            :                           size_t len, loff_t *ppos);
    3505                 :            : 
    3506                 :            : struct ctl_table;
    3507                 :            : int proc_nr_files(struct ctl_table *table, int write,
    3508                 :            :                   void __user *buffer, size_t *lenp, loff_t *ppos);
    3509                 :            : int proc_nr_dentry(struct ctl_table *table, int write,
    3510                 :            :                   void __user *buffer, size_t *lenp, loff_t *ppos);
    3511                 :            : int proc_nr_inodes(struct ctl_table *table, int write,
    3512                 :            :                    void __user *buffer, size_t *lenp, loff_t *ppos);
    3513                 :            : int __init get_filesystem_list(char *buf);
    3514                 :            : 
    3515                 :            : #define __FMODE_EXEC            ((__force int) FMODE_EXEC)
    3516                 :            : #define __FMODE_NONOTIFY        ((__force int) FMODE_NONOTIFY)
    3517                 :            : 
    3518                 :            : #define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
    3519                 :            : #define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
    3520                 :            :                                             (flag & __FMODE_NONOTIFY)))
    3521                 :            : 
    3522                 :            : static inline bool is_sxid(umode_t mode)
    3523                 :            : {
    3524                 :          3 :         return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
    3525                 :            : }
    3526                 :            : 
    3527                 :            : static inline int check_sticky(struct inode *dir, struct inode *inode)
    3528                 :            : {
    3529                 :          3 :         if (!(dir->i_mode & S_ISVTX))
    3530                 :            :                 return 0;
    3531                 :            : 
    3532                 :          3 :         return __check_sticky(dir, inode);
    3533                 :            : }
    3534                 :            : 
    3535                 :          3 : static inline void inode_has_no_xattr(struct inode *inode)
    3536                 :            : {
    3537                 :          3 :         if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & SB_NOSEC))
    3538                 :          3 :                 inode->i_flags |= S_NOSEC;
    3539                 :          3 : }
    3540                 :            : 
    3541                 :            : static inline bool is_root_inode(struct inode *inode)
    3542                 :            : {
    3543                 :            :         return inode == inode->i_sb->s_root->d_inode;
    3544                 :            : }
    3545                 :            : 
    3546                 :            : static inline bool dir_emit(struct dir_context *ctx,
    3547                 :            :                             const char *name, int namelen,
    3548                 :            :                             u64 ino, unsigned type)
    3549                 :            : {
    3550                 :          3 :         return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
    3551                 :            : }
    3552                 :          3 : static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
    3553                 :            : {
    3554                 :          3 :         return ctx->actor(ctx, ".", 1, ctx->pos,
    3555                 :          3 :                           file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
    3556                 :            : }
    3557                 :          3 : static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
    3558                 :            : {
    3559                 :          3 :         return ctx->actor(ctx, "..", 2, ctx->pos,
    3560                 :          3 :                           parent_ino(file->f_path.dentry), DT_DIR) == 0;
    3561                 :            : }
    3562                 :          3 : static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
    3563                 :            : {
    3564                 :          3 :         if (ctx->pos == 0) {
    3565                 :          3 :                 if (!dir_emit_dot(file, ctx))
    3566                 :            :                         return false;
    3567                 :          3 :                 ctx->pos = 1;
    3568                 :            :         }
    3569                 :          3 :         if (ctx->pos == 1) {
    3570                 :          3 :                 if (!dir_emit_dotdot(file, ctx))
    3571                 :            :                         return false;
    3572                 :          3 :                 ctx->pos = 2;
    3573                 :            :         }
    3574                 :            :         return true;
    3575                 :            : }
    3576                 :            : static inline bool dir_relax(struct inode *inode)
    3577                 :            : {
    3578                 :            :         inode_unlock(inode);
    3579                 :            :         inode_lock(inode);
    3580                 :            :         return !IS_DEADDIR(inode);
    3581                 :            : }
    3582                 :            : 
    3583                 :          0 : static inline bool dir_relax_shared(struct inode *inode)
    3584                 :            : {
    3585                 :            :         inode_unlock_shared(inode);
    3586                 :            :         inode_lock_shared(inode);
    3587                 :          0 :         return !IS_DEADDIR(inode);
    3588                 :            : }
    3589                 :            : 
    3590                 :            : extern bool path_noexec(const struct path *path);
    3591                 :            : extern void inode_nohighmem(struct inode *inode);
    3592                 :            : 
    3593                 :            : /* mm/fadvise.c */
    3594                 :            : extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
    3595                 :            :                        int advice);
    3596                 :            : extern int generic_fadvise(struct file *file, loff_t offset, loff_t len,
    3597                 :            :                            int advice);
    3598                 :            : 
    3599                 :            : #if defined(CONFIG_IO_URING)
    3600                 :            : extern struct sock *io_uring_get_socket(struct file *file);
    3601                 :            : #else
    3602                 :            : static inline struct sock *io_uring_get_socket(struct file *file)
    3603                 :            : {
    3604                 :            :         return NULL;
    3605                 :            : }
    3606                 :            : #endif
    3607                 :            : 
    3608                 :            : int vfs_ioc_setflags_prepare(struct inode *inode, unsigned int oldflags,
    3609                 :            :                              unsigned int flags);
    3610                 :            : 
    3611                 :            : int vfs_ioc_fssetxattr_check(struct inode *inode, const struct fsxattr *old_fa,
    3612                 :            :                              struct fsxattr *fa);
    3613                 :            : 
    3614                 :            : static inline void simple_fill_fsxattr(struct fsxattr *fa, __u32 xflags)
    3615                 :            : {
    3616                 :          0 :         memset(fa, 0, sizeof(*fa));
    3617                 :          0 :         fa->fsx_xflags = xflags;
    3618                 :            : }
    3619                 :            : 
    3620                 :            : /*
    3621                 :            :  * Flush file data before changing attributes.  Caller must hold any locks
    3622                 :            :  * required to prevent further writes to this file until we're done setting
    3623                 :            :  * flags.
    3624                 :            :  */
    3625                 :            : static inline int inode_drain_writes(struct inode *inode)
    3626                 :            : {
    3627                 :          3 :         inode_dio_wait(inode);
    3628                 :          3 :         return filemap_write_and_wait(inode->i_mapping);
    3629                 :            : }
    3630                 :            : 
    3631                 :            : #endif /* _LINUX_FS_H */
    

Generated by: LCOV version 1.14