Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  *  linux/include/linux/nfs_fs.h
       4                 :            :  *
       5                 :            :  *  Copyright (C) 1992  Rick Sladkey
       6                 :            :  *
       7                 :            :  *  OS-specific nfs filesystem definitions and declarations
       8                 :            :  */
       9                 :            : #ifndef _LINUX_NFS_FS_H
      10                 :            : #define _LINUX_NFS_FS_H
      11                 :            : 
      12                 :            : #include <uapi/linux/nfs_fs.h>
      13                 :            : 
      14                 :            : 
      15                 :            : /*
      16                 :            :  * Enable dprintk() debugging support for nfs client.
      17                 :            :  */
      18                 :            : #ifdef CONFIG_NFS_DEBUG
      19                 :            : # define NFS_DEBUG
      20                 :            : #endif
      21                 :            : 
      22                 :            : #include <linux/in.h>
      23                 :            : #include <linux/mm.h>
      24                 :            : #include <linux/pagemap.h>
      25                 :            : #include <linux/rbtree.h>
      26                 :            : #include <linux/refcount.h>
      27                 :            : #include <linux/rwsem.h>
      28                 :            : #include <linux/wait.h>
      29                 :            : 
      30                 :            : #include <linux/sunrpc/debug.h>
      31                 :            : #include <linux/sunrpc/auth.h>
      32                 :            : #include <linux/sunrpc/clnt.h>
      33                 :            : 
      34                 :            : #include <linux/nfs.h>
      35                 :            : #include <linux/nfs2.h>
      36                 :            : #include <linux/nfs3.h>
      37                 :            : #include <linux/nfs4.h>
      38                 :            : #include <linux/nfs_xdr.h>
      39                 :            : #include <linux/nfs_fs_sb.h>
      40                 :            : 
      41                 :            : #include <linux/mempool.h>
      42                 :            : 
      43                 :            : /*
      44                 :            :  * These are the default flags for swap requests
      45                 :            :  */
      46                 :            : #define NFS_RPC_SWAPFLAGS               (RPC_TASK_SWAPPER|RPC_TASK_ROOTCREDS)
      47                 :            : 
      48                 :            : /*
      49                 :            :  * NFSv3/v4 Access mode cache entry
      50                 :            :  */
      51                 :            : struct nfs_access_entry {
      52                 :            :         struct rb_node          rb_node;
      53                 :            :         struct list_head        lru;
      54                 :            :         const struct cred *     cred;
      55                 :            :         __u32                   mask;
      56                 :            :         struct rcu_head         rcu_head;
      57                 :            : };
      58                 :            : 
      59                 :            : struct nfs_lock_context {
      60                 :            :         refcount_t count;
      61                 :            :         struct list_head list;
      62                 :            :         struct nfs_open_context *open_context;
      63                 :            :         fl_owner_t lockowner;
      64                 :            :         atomic_t io_count;
      65                 :            :         struct rcu_head rcu_head;
      66                 :            : };
      67                 :            : 
      68                 :            : struct nfs4_state;
      69                 :            : struct nfs_open_context {
      70                 :            :         struct nfs_lock_context lock_context;
      71                 :            :         fl_owner_t flock_owner;
      72                 :            :         struct dentry *dentry;
      73                 :            :         const struct cred *cred;
      74                 :            :         struct rpc_cred *ll_cred;       /* low-level cred - use to check for expiry */
      75                 :            :         struct nfs4_state *state;
      76                 :            :         fmode_t mode;
      77                 :            : 
      78                 :            :         unsigned long flags;
      79                 :            : #define NFS_CONTEXT_RESEND_WRITES       (1)
      80                 :            : #define NFS_CONTEXT_BAD                 (2)
      81                 :            : #define NFS_CONTEXT_UNLOCK      (3)
      82                 :            :         int error;
      83                 :            : 
      84                 :            :         struct list_head list;
      85                 :            :         struct nfs4_threshold   *mdsthreshold;
      86                 :            :         struct rcu_head rcu_head;
      87                 :            : };
      88                 :            : 
      89                 :            : struct nfs_open_dir_context {
      90                 :            :         struct list_head list;
      91                 :            :         const struct cred *cred;
      92                 :            :         unsigned long attr_gencount;
      93                 :            :         __u64 dir_cookie;
      94                 :            :         __u64 dup_cookie;
      95                 :            :         signed char duped;
      96                 :            : };
      97                 :            : 
      98                 :            : /*
      99                 :            :  * NFSv4 delegation
     100                 :            :  */
     101                 :            : struct nfs_delegation;
     102                 :            : 
     103                 :            : struct posix_acl;
     104                 :            : 
     105                 :            : /*
     106                 :            :  * nfs fs inode data in memory
     107                 :            :  */
     108                 :            : struct nfs_inode {
     109                 :            :         /*
     110                 :            :          * The 64bit 'inode number'
     111                 :            :          */
     112                 :            :         __u64 fileid;
     113                 :            : 
     114                 :            :         /*
     115                 :            :          * NFS file handle
     116                 :            :          */
     117                 :            :         struct nfs_fh           fh;
     118                 :            : 
     119                 :            :         /*
     120                 :            :          * Various flags
     121                 :            :          */
     122                 :            :         unsigned long           flags;                  /* atomic bit ops */
     123                 :            :         unsigned long           cache_validity;         /* bit mask */
     124                 :            : 
     125                 :            :         /*
     126                 :            :          * read_cache_jiffies is when we started read-caching this inode.
     127                 :            :          * attrtimeo is for how long the cached information is assumed
     128                 :            :          * to be valid. A successful attribute revalidation doubles
     129                 :            :          * attrtimeo (up to acregmax/acdirmax), a failure resets it to
     130                 :            :          * acregmin/acdirmin.
     131                 :            :          *
     132                 :            :          * We need to revalidate the cached attrs for this inode if
     133                 :            :          *
     134                 :            :          *      jiffies - read_cache_jiffies >= attrtimeo
     135                 :            :          *
     136                 :            :          * Please note the comparison is greater than or equal
     137                 :            :          * so that zero timeout values can be specified.
     138                 :            :          */
     139                 :            :         unsigned long           read_cache_jiffies;
     140                 :            :         unsigned long           attrtimeo;
     141                 :            :         unsigned long           attrtimeo_timestamp;
     142                 :            : 
     143                 :            :         unsigned long           attr_gencount;
     144                 :            :         /* "Generation counter" for the attribute cache. This is
     145                 :            :          * bumped whenever we update the metadata on the
     146                 :            :          * server.
     147                 :            :          */
     148                 :            :         unsigned long           cache_change_attribute;
     149                 :            : 
     150                 :            :         struct rb_root          access_cache;
     151                 :            :         struct list_head        access_cache_entry_lru;
     152                 :            :         struct list_head        access_cache_inode_lru;
     153                 :            : 
     154                 :            :         /*
     155                 :            :          * This is the cookie verifier used for NFSv3 readdir
     156                 :            :          * operations
     157                 :            :          */
     158                 :            :         __be32                  cookieverf[2];
     159                 :            : 
     160                 :            :         atomic_long_t           nrequests;
     161                 :            :         struct nfs_mds_commit_info commit_info;
     162                 :            : 
     163                 :            :         /* Open contexts for shared mmap writes */
     164                 :            :         struct list_head        open_files;
     165                 :            : 
     166                 :            :         /* Readers: in-flight sillydelete RPC calls */
     167                 :            :         /* Writers: rmdir */
     168                 :            :         struct rw_semaphore     rmdir_sem;
     169                 :            :         struct mutex            commit_mutex;
     170                 :            : 
     171                 :            : #if IS_ENABLED(CONFIG_NFS_V4)
     172                 :            :         struct nfs4_cached_acl  *nfs4_acl;
     173                 :            :         /* NFSv4 state */
     174                 :            :         struct list_head        open_states;
     175                 :            :         struct nfs_delegation __rcu *delegation;
     176                 :            :         struct rw_semaphore     rwsem;
     177                 :            : 
     178                 :            :         /* pNFS layout information */
     179                 :            :         struct pnfs_layout_hdr *layout;
     180                 :            : #endif /* CONFIG_NFS_V4*/
     181                 :            :         /* how many bytes have been written/read and how many bytes queued up */
     182                 :            :         __u64 write_io;
     183                 :            :         __u64 read_io;
     184                 :            : #ifdef CONFIG_NFS_FSCACHE
     185                 :            :         struct fscache_cookie   *fscache;
     186                 :            : #endif
     187                 :            :         struct inode            vfs_inode;
     188                 :            : };
     189                 :            : 
     190                 :            : struct nfs4_copy_state {
     191                 :            :         struct list_head        copies;
     192                 :            :         nfs4_stateid            stateid;
     193                 :            :         struct completion       completion;
     194                 :            :         uint64_t                count;
     195                 :            :         struct nfs_writeverf    verf;
     196                 :            :         int                     error;
     197                 :            :         int                     flags;
     198                 :            :         struct nfs4_state       *parent_state;
     199                 :            : };
     200                 :            : 
     201                 :            : /*
     202                 :            :  * Access bit flags
     203                 :            :  */
     204                 :            : #define NFS_ACCESS_READ        0x0001
     205                 :            : #define NFS_ACCESS_LOOKUP      0x0002
     206                 :            : #define NFS_ACCESS_MODIFY      0x0004
     207                 :            : #define NFS_ACCESS_EXTEND      0x0008
     208                 :            : #define NFS_ACCESS_DELETE      0x0010
     209                 :            : #define NFS_ACCESS_EXECUTE     0x0020
     210                 :            : 
     211                 :            : /*
     212                 :            :  * Cache validity bit flags
     213                 :            :  */
     214                 :            : #define NFS_INO_INVALID_DATA    BIT(1)          /* cached data is invalid */
     215                 :            : #define NFS_INO_INVALID_ATIME   BIT(2)          /* cached atime is invalid */
     216                 :            : #define NFS_INO_INVALID_ACCESS  BIT(3)          /* cached access cred invalid */
     217                 :            : #define NFS_INO_INVALID_ACL     BIT(4)          /* cached acls are invalid */
     218                 :            : #define NFS_INO_REVAL_PAGECACHE BIT(5)          /* must revalidate pagecache */
     219                 :            : #define NFS_INO_REVAL_FORCED    BIT(6)          /* force revalidation ignoring a delegation */
     220                 :            : #define NFS_INO_INVALID_LABEL   BIT(7)          /* cached label is invalid */
     221                 :            : #define NFS_INO_INVALID_CHANGE  BIT(8)          /* cached change is invalid */
     222                 :            : #define NFS_INO_INVALID_CTIME   BIT(9)          /* cached ctime is invalid */
     223                 :            : #define NFS_INO_INVALID_MTIME   BIT(10)         /* cached mtime is invalid */
     224                 :            : #define NFS_INO_INVALID_SIZE    BIT(11)         /* cached size is invalid */
     225                 :            : #define NFS_INO_INVALID_OTHER   BIT(12)         /* other attrs are invalid */
     226                 :            : #define NFS_INO_DATA_INVAL_DEFER        \
     227                 :            :                                 BIT(13)         /* Deferred cache invalidation */
     228                 :            : #define NFS_INO_INVALID_BLOCKS  BIT(14)         /* cached blocks are invalid */
     229                 :            : 
     230                 :            : #define NFS_INO_INVALID_ATTR    (NFS_INO_INVALID_CHANGE \
     231                 :            :                 | NFS_INO_INVALID_CTIME \
     232                 :            :                 | NFS_INO_INVALID_MTIME \
     233                 :            :                 | NFS_INO_INVALID_SIZE \
     234                 :            :                 | NFS_INO_INVALID_OTHER)        /* inode metadata is invalid */
     235                 :            : 
     236                 :            : /*
     237                 :            :  * Bit offsets in flags field
     238                 :            :  */
     239                 :            : #define NFS_INO_ADVISE_RDPLUS   (0)             /* advise readdirplus */
     240                 :            : #define NFS_INO_STALE           (1)             /* possible stale inode */
     241                 :            : #define NFS_INO_ACL_LRU_SET     (2)             /* Inode is on the LRU list */
     242                 :            : #define NFS_INO_INVALIDATING    (3)             /* inode is being invalidated */
     243                 :            : #define NFS_INO_FSCACHE         (5)             /* inode can be cached by FS-Cache */
     244                 :            : #define NFS_INO_FSCACHE_LOCK    (6)             /* FS-Cache cookie management lock */
     245                 :            : #define NFS_INO_LAYOUTCOMMIT    (9)             /* layoutcommit required */
     246                 :            : #define NFS_INO_LAYOUTCOMMITTING (10)           /* layoutcommit inflight */
     247                 :            : #define NFS_INO_LAYOUTSTATS     (11)            /* layoutstats inflight */
     248                 :            : #define NFS_INO_ODIRECT         (12)            /* I/O setting is O_DIRECT */
     249                 :            : 
     250                 :            : static inline struct nfs_inode *NFS_I(const struct inode *inode)
     251                 :            : {
     252                 :          0 :         return container_of(inode, struct nfs_inode, vfs_inode);
     253                 :            : }
     254                 :            : 
     255                 :            : static inline struct nfs_server *NFS_SB(const struct super_block *s)
     256                 :            : {
     257                 :          0 :         return (struct nfs_server *)(s->s_fs_info);
     258                 :            : }
     259                 :            : 
     260                 :            : static inline struct nfs_fh *NFS_FH(const struct inode *inode)
     261                 :            : {
     262                 :          0 :         return &NFS_I(inode)->fh;
     263                 :            : }
     264                 :            : 
     265                 :            : static inline struct nfs_server *NFS_SERVER(const struct inode *inode)
     266                 :            : {
     267                 :          0 :         return NFS_SB(inode->i_sb);
     268                 :            : }
     269                 :            : 
     270                 :            : static inline struct rpc_clnt *NFS_CLIENT(const struct inode *inode)
     271                 :            : {
     272                 :          0 :         return NFS_SERVER(inode)->client;
     273                 :            : }
     274                 :            : 
     275                 :            : static inline const struct nfs_rpc_ops *NFS_PROTO(const struct inode *inode)
     276                 :            : {
     277                 :          0 :         return NFS_SERVER(inode)->nfs_client->rpc_ops;
     278                 :            : }
     279                 :            : 
     280                 :            : static inline unsigned NFS_MINATTRTIMEO(const struct inode *inode)
     281                 :            : {
     282                 :            :         struct nfs_server *nfss = NFS_SERVER(inode);
     283                 :          0 :         return S_ISDIR(inode->i_mode) ? nfss->acdirmin : nfss->acregmin;
     284                 :            : }
     285                 :            : 
     286                 :            : static inline unsigned NFS_MAXATTRTIMEO(const struct inode *inode)
     287                 :            : {
     288                 :            :         struct nfs_server *nfss = NFS_SERVER(inode);
     289                 :          0 :         return S_ISDIR(inode->i_mode) ? nfss->acdirmax : nfss->acregmax;
     290                 :            : }
     291                 :            : 
     292                 :            : static inline int NFS_STALE(const struct inode *inode)
     293                 :            : {
     294                 :            :         return test_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
     295                 :            : }
     296                 :            : 
     297                 :            : static inline struct fscache_cookie *nfs_i_fscache(struct inode *inode)
     298                 :            : {
     299                 :            : #ifdef CONFIG_NFS_FSCACHE
     300                 :          0 :         return NFS_I(inode)->fscache;
     301                 :            : #else
     302                 :            :         return NULL;
     303                 :            : #endif
     304                 :            : }
     305                 :            : 
     306                 :            : static inline __u64 NFS_FILEID(const struct inode *inode)
     307                 :            : {
     308                 :          0 :         return NFS_I(inode)->fileid;
     309                 :            : }
     310                 :            : 
     311                 :            : static inline void set_nfs_fileid(struct inode *inode, __u64 fileid)
     312                 :            : {
     313                 :          0 :         NFS_I(inode)->fileid = fileid;
     314                 :            : }
     315                 :            : 
     316                 :          0 : static inline void nfs_mark_for_revalidate(struct inode *inode)
     317                 :            : {
     318                 :            :         struct nfs_inode *nfsi = NFS_I(inode);
     319                 :            : 
     320                 :            :         spin_lock(&inode->i_lock);
     321                 :          0 :         nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE
     322                 :            :                 | NFS_INO_INVALID_ACCESS
     323                 :            :                 | NFS_INO_INVALID_ACL
     324                 :            :                 | NFS_INO_INVALID_CHANGE
     325                 :            :                 | NFS_INO_INVALID_CTIME;
     326                 :          0 :         if (S_ISDIR(inode->i_mode))
     327                 :          0 :                 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
     328                 :            :         spin_unlock(&inode->i_lock);
     329                 :          0 : }
     330                 :            : 
     331                 :            : static inline int nfs_server_capable(struct inode *inode, int cap)
     332                 :            : {
     333                 :          0 :         return NFS_SERVER(inode)->caps & cap;
     334                 :            : }
     335                 :            : 
     336                 :            : static inline void nfs_set_verifier(struct dentry * dentry, unsigned long verf)
     337                 :            : {
     338                 :          0 :         dentry->d_time = verf;
     339                 :            : }
     340                 :            : 
     341                 :            : /**
     342                 :            :  * nfs_save_change_attribute - Returns the inode attribute change cookie
     343                 :            :  * @dir - pointer to parent directory inode
     344                 :            :  * The "change attribute" is updated every time we finish an operation
     345                 :            :  * that will result in a metadata change on the server.
     346                 :            :  */
     347                 :            : static inline unsigned long nfs_save_change_attribute(struct inode *dir)
     348                 :            : {
     349                 :          0 :         return NFS_I(dir)->cache_change_attribute;
     350                 :            : }
     351                 :            : 
     352                 :            : /**
     353                 :            :  * nfs_verify_change_attribute - Detects NFS remote directory changes
     354                 :            :  * @dir - pointer to parent directory inode
     355                 :            :  * @chattr - previously saved change attribute
     356                 :            :  * Return "false" if the verifiers doesn't match the change attribute.
     357                 :            :  * This would usually indicate that the directory contents have changed on
     358                 :            :  * the server, and that any dentries need revalidating.
     359                 :            :  */
     360                 :            : static inline int nfs_verify_change_attribute(struct inode *dir, unsigned long chattr)
     361                 :            : {
     362                 :          0 :         return chattr == NFS_I(dir)->cache_change_attribute;
     363                 :            : }
     364                 :            : 
     365                 :            : /*
     366                 :            :  * linux/fs/nfs/inode.c
     367                 :            :  */
     368                 :            : extern int nfs_sync_mapping(struct address_space *mapping);
     369                 :            : extern void nfs_zap_mapping(struct inode *inode, struct address_space *mapping);
     370                 :            : extern void nfs_zap_caches(struct inode *);
     371                 :            : extern void nfs_invalidate_atime(struct inode *);
     372                 :            : extern struct inode *nfs_fhget(struct super_block *, struct nfs_fh *,
     373                 :            :                                 struct nfs_fattr *, struct nfs4_label *);
     374                 :            : struct inode *nfs_ilookup(struct super_block *sb, struct nfs_fattr *, struct nfs_fh *);
     375                 :            : extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
     376                 :            : extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr);
     377                 :            : extern int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr);
     378                 :            : extern int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr);
     379                 :            : extern int nfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
     380                 :            : extern void nfs_access_add_cache(struct inode *, struct nfs_access_entry *);
     381                 :            : extern void nfs_access_set_mask(struct nfs_access_entry *, u32);
     382                 :            : extern int nfs_permission(struct inode *, int);
     383                 :            : extern int nfs_open(struct inode *, struct file *);
     384                 :            : extern int nfs_attribute_cache_expired(struct inode *inode);
     385                 :            : extern int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode);
     386                 :            : extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
     387                 :            : extern bool nfs_mapping_need_revalidate_inode(struct inode *inode);
     388                 :            : extern int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping);
     389                 :            : extern int nfs_revalidate_mapping_rcu(struct inode *inode);
     390                 :            : extern int nfs_setattr(struct dentry *, struct iattr *);
     391                 :            : extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr, struct nfs_fattr *);
     392                 :            : extern void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
     393                 :            :                                 struct nfs4_label *label);
     394                 :            : extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
     395                 :            : extern void put_nfs_open_context(struct nfs_open_context *ctx);
     396                 :            : extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode);
     397                 :            : extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode, struct file *filp);
     398                 :            : extern void nfs_inode_attach_open_context(struct nfs_open_context *ctx);
     399                 :            : extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
     400                 :            : extern void nfs_file_clear_open_context(struct file *flip);
     401                 :            : extern struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx);
     402                 :            : extern void nfs_put_lock_context(struct nfs_lock_context *l_ctx);
     403                 :            : extern u64 nfs_compat_user_ino64(u64 fileid);
     404                 :            : extern void nfs_fattr_init(struct nfs_fattr *fattr);
     405                 :            : extern void nfs_fattr_set_barrier(struct nfs_fattr *fattr);
     406                 :            : extern unsigned long nfs_inc_attr_generation_counter(void);
     407                 :            : 
     408                 :            : extern struct nfs_fattr *nfs_alloc_fattr(void);
     409                 :            : 
     410                 :            : static inline void nfs_free_fattr(const struct nfs_fattr *fattr)
     411                 :            : {
     412                 :          0 :         kfree(fattr);
     413                 :            : }
     414                 :            : 
     415                 :            : extern struct nfs_fh *nfs_alloc_fhandle(void);
     416                 :            : 
     417                 :            : static inline void nfs_free_fhandle(const struct nfs_fh *fh)
     418                 :            : {
     419                 :          0 :         kfree(fh);
     420                 :            : }
     421                 :            : 
     422                 :            : #ifdef NFS_DEBUG
     423                 :            : extern u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh);
     424                 :            : static inline u32 nfs_display_fhandle_hash(const struct nfs_fh *fh)
     425                 :            : {
     426                 :            :         return _nfs_display_fhandle_hash(fh);
     427                 :            : }
     428                 :            : extern void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption);
     429                 :            : #define nfs_display_fhandle(fh, caption)                        \
     430                 :            :         do {                                                    \
     431                 :            :                 if (unlikely(nfs_debug & NFSDBG_FACILITY))  \
     432                 :            :                         _nfs_display_fhandle(fh, caption);      \
     433                 :            :         } while (0)
     434                 :            : #else
     435                 :            : static inline u32 nfs_display_fhandle_hash(const struct nfs_fh *fh)
     436                 :            : {
     437                 :            :         return 0;
     438                 :            : }
     439                 :            : static inline void nfs_display_fhandle(const struct nfs_fh *fh,
     440                 :            :                                        const char *caption)
     441                 :            : {
     442                 :            : }
     443                 :            : #endif
     444                 :            : 
     445                 :            : /*
     446                 :            :  * linux/fs/nfs/nfsroot.c
     447                 :            :  */
     448                 :            : extern int  nfs_root_data(char **root_device, char **root_data); /*__init*/
     449                 :            : /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */
     450                 :            : extern __be32 root_nfs_parse_addr(char *name); /*__init*/
     451                 :            : 
     452                 :            : /*
     453                 :            :  * linux/fs/nfs/file.c
     454                 :            :  */
     455                 :            : extern const struct file_operations nfs_file_operations;
     456                 :            : #if IS_ENABLED(CONFIG_NFS_V4)
     457                 :            : extern const struct file_operations nfs4_file_operations;
     458                 :            : #endif /* CONFIG_NFS_V4 */
     459                 :            : extern const struct address_space_operations nfs_file_aops;
     460                 :            : extern const struct address_space_operations nfs_dir_aops;
     461                 :            : 
     462                 :            : static inline struct nfs_open_context *nfs_file_open_context(struct file *filp)
     463                 :            : {
     464                 :          0 :         return filp->private_data;
     465                 :            : }
     466                 :            : 
     467                 :            : static inline const struct cred *nfs_file_cred(struct file *file)
     468                 :            : {
     469                 :          0 :         if (file != NULL) {
     470                 :            :                 struct nfs_open_context *ctx =
     471                 :            :                         nfs_file_open_context(file);
     472                 :          0 :                 if (ctx)
     473                 :          0 :                         return ctx->cred;
     474                 :            :         }
     475                 :            :         return NULL;
     476                 :            : }
     477                 :            : 
     478                 :            : /*
     479                 :            :  * linux/fs/nfs/direct.c
     480                 :            :  */
     481                 :            : extern ssize_t nfs_direct_IO(struct kiocb *, struct iov_iter *);
     482                 :            : extern ssize_t nfs_file_direct_read(struct kiocb *iocb,
     483                 :            :                         struct iov_iter *iter);
     484                 :            : extern ssize_t nfs_file_direct_write(struct kiocb *iocb,
     485                 :            :                         struct iov_iter *iter);
     486                 :            : 
     487                 :            : /*
     488                 :            :  * linux/fs/nfs/dir.c
     489                 :            :  */
     490                 :            : extern const struct file_operations nfs_dir_operations;
     491                 :            : extern const struct dentry_operations nfs_dentry_operations;
     492                 :            : 
     493                 :            : extern void nfs_force_lookup_revalidate(struct inode *dir);
     494                 :            : extern struct dentry *nfs_add_or_obtain(struct dentry *dentry,
     495                 :            :                         struct nfs_fh *fh, struct nfs_fattr *fattr,
     496                 :            :                         struct nfs4_label *label);
     497                 :            : extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh,
     498                 :            :                         struct nfs_fattr *fattr, struct nfs4_label *label);
     499                 :            : extern int nfs_may_open(struct inode *inode, const struct cred *cred, int openflags);
     500                 :            : extern void nfs_access_zap_cache(struct inode *inode);
     501                 :            : 
     502                 :            : /*
     503                 :            :  * linux/fs/nfs/symlink.c
     504                 :            :  */
     505                 :            : extern const struct inode_operations nfs_symlink_inode_operations;
     506                 :            : 
     507                 :            : /*
     508                 :            :  * linux/fs/nfs/sysctl.c
     509                 :            :  */
     510                 :            : #ifdef CONFIG_SYSCTL
     511                 :            : extern int nfs_register_sysctl(void);
     512                 :            : extern void nfs_unregister_sysctl(void);
     513                 :            : #else
     514                 :            : #define nfs_register_sysctl() 0
     515                 :            : #define nfs_unregister_sysctl() do { } while(0)
     516                 :            : #endif
     517                 :            : 
     518                 :            : /*
     519                 :            :  * linux/fs/nfs/namespace.c
     520                 :            :  */
     521                 :            : extern const struct inode_operations nfs_mountpoint_inode_operations;
     522                 :            : extern const struct inode_operations nfs_referral_inode_operations;
     523                 :            : extern int nfs_mountpoint_expiry_timeout;
     524                 :            : extern void nfs_release_automount_timer(void);
     525                 :            : 
     526                 :            : /*
     527                 :            :  * linux/fs/nfs/unlink.c
     528                 :            :  */
     529                 :            : extern void nfs_complete_unlink(struct dentry *dentry, struct inode *);
     530                 :            : 
     531                 :            : /*
     532                 :            :  * linux/fs/nfs/write.c
     533                 :            :  */
     534                 :            : extern int  nfs_congestion_kb;
     535                 :            : extern int  nfs_writepage(struct page *page, struct writeback_control *wbc);
     536                 :            : extern int  nfs_writepages(struct address_space *, struct writeback_control *);
     537                 :            : extern int  nfs_flush_incompatible(struct file *file, struct page *page);
     538                 :            : extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
     539                 :            : 
     540                 :            : /*
     541                 :            :  * Try to write back everything synchronously (but check the
     542                 :            :  * return value!)
     543                 :            :  */
     544                 :            : extern int nfs_sync_inode(struct inode *inode);
     545                 :            : extern int nfs_wb_all(struct inode *inode);
     546                 :            : extern int nfs_wb_page(struct inode *inode, struct page *page);
     547                 :            : extern int nfs_wb_page_cancel(struct inode *inode, struct page* page);
     548                 :            : extern int  nfs_commit_inode(struct inode *, int);
     549                 :            : extern struct nfs_commit_data *nfs_commitdata_alloc(bool never_fail);
     550                 :            : extern void nfs_commit_free(struct nfs_commit_data *data);
     551                 :            : 
     552                 :            : static inline int
     553                 :            : nfs_have_writebacks(struct inode *inode)
     554                 :            : {
     555                 :          0 :         return atomic_long_read(&NFS_I(inode)->nrequests) != 0;
     556                 :            : }
     557                 :            : 
     558                 :            : /*
     559                 :            :  * linux/fs/nfs/read.c
     560                 :            :  */
     561                 :            : extern int  nfs_readpage(struct file *, struct page *);
     562                 :            : extern int  nfs_readpages(struct file *, struct address_space *,
     563                 :            :                 struct list_head *, unsigned);
     564                 :            : extern int  nfs_readpage_async(struct nfs_open_context *, struct inode *,
     565                 :            :                                struct page *);
     566                 :            : 
     567                 :            : /*
     568                 :            :  * inline functions
     569                 :            :  */
     570                 :            : 
     571                 :            : static inline loff_t nfs_size_to_loff_t(__u64 size)
     572                 :            : {
     573                 :          0 :         return min_t(u64, size, OFFSET_MAX);
     574                 :            : }
     575                 :            : 
     576                 :            : static inline ino_t
     577                 :            : nfs_fileid_to_ino_t(u64 fileid)
     578                 :            : {
     579                 :          0 :         ino_t ino = (ino_t) fileid;
     580                 :            :         if (sizeof(ino_t) < sizeof(u64))
     581                 :          0 :                 ino ^= fileid >> (sizeof(u64)-sizeof(ino_t)) * 8;
     582                 :            :         return ino;
     583                 :            : }
     584                 :            : 
     585                 :            : #define NFS_JUKEBOX_RETRY_TIME (5 * HZ)
     586                 :            : 
     587                 :            : 
     588                 :            : # undef ifdebug
     589                 :            : # ifdef NFS_DEBUG
     590                 :            : #  define ifdebug(fac)          if (unlikely(nfs_debug & NFSDBG_##fac))
     591                 :            : #  define NFS_IFDEBUG(x)        x
     592                 :            : # else
     593                 :            : #  define ifdebug(fac)          if (0)
     594                 :            : #  define NFS_IFDEBUG(x)
     595                 :            : # endif
     596                 :            : #endif