LCOV - code coverage report
Current view: top level - fs/nfs - internal.h (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 83 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 12 0.0 %
Branches: 0 86 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * NFS internal definitions
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "nfs4_fs.h"
       7                 :            : #include <linux/mount.h>
       8                 :            : #include <linux/security.h>
       9                 :            : #include <linux/crc32.h>
      10                 :            : #include <linux/nfs_page.h>
      11                 :            : #include <linux/wait_bit.h>
      12                 :            : 
      13                 :            : #define NFS_MS_MASK (SB_RDONLY|SB_NOSUID|SB_NODEV|SB_NOEXEC|SB_SYNCHRONOUS)
      14                 :            : 
      15                 :            : extern const struct export_operations nfs_export_ops;
      16                 :            : 
      17                 :            : struct nfs_string;
      18                 :            : 
      19                 :          0 : static inline void nfs_attr_check_mountpoint(struct super_block *parent, struct nfs_fattr *fattr)
      20                 :            : {
      21         [ #  # ]:          0 :         if (!nfs_fsid_equal(&NFS_SB(parent)->fsid, &fattr->fsid))
      22                 :          0 :                 fattr->valid |= NFS_ATTR_FATTR_MOUNTPOINT;
      23                 :          0 : }
      24                 :            : 
      25                 :            : static inline int nfs_attr_use_mounted_on_fileid(struct nfs_fattr *fattr)
      26                 :            : {
      27   [ #  #  #  # ]:          0 :         if (((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) == 0) ||
      28                 :          0 :             (((fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT) == 0) &&
      29                 :            :              ((fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) == 0)))
      30                 :            :                 return 0;
      31                 :            :         return 1;
      32                 :            : }
      33                 :            : 
      34                 :            : struct nfs_clone_mount {
      35                 :            :         const struct super_block *sb;
      36                 :            :         const struct dentry *dentry;
      37                 :            :         struct nfs_fh *fh;
      38                 :            :         struct nfs_fattr *fattr;
      39                 :            :         char *hostname;
      40                 :            :         char *mnt_path;
      41                 :            :         struct sockaddr *addr;
      42                 :            :         size_t addrlen;
      43                 :            :         rpc_authflavor_t authflavor;
      44                 :            : };
      45                 :            : 
      46                 :            : /*
      47                 :            :  * Note: RFC 1813 doesn't limit the number of auth flavors that
      48                 :            :  * a server can return, so make something up.
      49                 :            :  */
      50                 :            : #define NFS_MAX_SECFLAVORS      (12)
      51                 :            : 
      52                 :            : /*
      53                 :            :  * Value used if the user did not specify a port value.
      54                 :            :  */
      55                 :            : #define NFS_UNSPEC_PORT         (-1)
      56                 :            : 
      57                 :            : #define NFS_UNSPEC_RETRANS      (UINT_MAX)
      58                 :            : #define NFS_UNSPEC_TIMEO        (UINT_MAX)
      59                 :            : 
      60                 :            : /*
      61                 :            :  * Maximum number of pages that readdir can use for creating
      62                 :            :  * a vmapped array of pages.
      63                 :            :  */
      64                 :            : #define NFS_MAX_READDIR_PAGES 8
      65                 :            : 
      66                 :            : struct nfs_client_initdata {
      67                 :            :         unsigned long init_flags;
      68                 :            :         const char *hostname;                   /* Hostname of the server */
      69                 :            :         const struct sockaddr *addr;            /* Address of the server */
      70                 :            :         const char *nodename;                   /* Hostname of the client */
      71                 :            :         const char *ip_addr;                    /* IP address of the client */
      72                 :            :         size_t addrlen;
      73                 :            :         struct nfs_subversion *nfs_mod;
      74                 :            :         int proto;
      75                 :            :         u32 minorversion;
      76                 :            :         unsigned int nconnect;
      77                 :            :         struct net *net;
      78                 :            :         const struct rpc_timeout *timeparms;
      79                 :            :         const struct cred *cred;
      80                 :            : };
      81                 :            : 
      82                 :            : /*
      83                 :            :  * In-kernel mount arguments
      84                 :            :  */
      85                 :            : struct nfs_parsed_mount_data {
      86                 :            :         int                     flags;
      87                 :            :         unsigned int            rsize, wsize;
      88                 :            :         unsigned int            timeo, retrans;
      89                 :            :         unsigned int            acregmin, acregmax,
      90                 :            :                                 acdirmin, acdirmax;
      91                 :            :         unsigned int            namlen;
      92                 :            :         unsigned int            options;
      93                 :            :         unsigned int            bsize;
      94                 :            :         struct nfs_auth_info    auth_info;
      95                 :            :         rpc_authflavor_t        selected_flavor;
      96                 :            :         char                    *client_address;
      97                 :            :         unsigned int            version;
      98                 :            :         unsigned int            minorversion;
      99                 :            :         char                    *fscache_uniq;
     100                 :            :         bool                    need_mount;
     101                 :            : 
     102                 :            :         struct {
     103                 :            :                 struct sockaddr_storage address;
     104                 :            :                 size_t                  addrlen;
     105                 :            :                 char                    *hostname;
     106                 :            :                 u32                     version;
     107                 :            :                 int                     port;
     108                 :            :                 unsigned short          protocol;
     109                 :            :         } mount_server;
     110                 :            : 
     111                 :            :         struct {
     112                 :            :                 struct sockaddr_storage address;
     113                 :            :                 size_t                  addrlen;
     114                 :            :                 char                    *hostname;
     115                 :            :                 char                    *export_path;
     116                 :            :                 int                     port;
     117                 :            :                 unsigned short          protocol;
     118                 :            :                 unsigned short          nconnect;
     119                 :            :         } nfs_server;
     120                 :            : 
     121                 :            :         void                    *lsm_opts;
     122                 :            :         struct net              *net;
     123                 :            : };
     124                 :            : 
     125                 :            : /* mount_clnt.c */
     126                 :            : struct nfs_mount_request {
     127                 :            :         struct sockaddr         *sap;
     128                 :            :         size_t                  salen;
     129                 :            :         char                    *hostname;
     130                 :            :         char                    *dirpath;
     131                 :            :         u32                     version;
     132                 :            :         unsigned short          protocol;
     133                 :            :         struct nfs_fh           *fh;
     134                 :            :         int                     noresvport;
     135                 :            :         unsigned int            *auth_flav_len;
     136                 :            :         rpc_authflavor_t        *auth_flavs;
     137                 :            :         struct net              *net;
     138                 :            : };
     139                 :            : 
     140                 :            : struct nfs_mount_info {
     141                 :            :         void (*fill_super)(struct super_block *, struct nfs_mount_info *);
     142                 :            :         int (*set_security)(struct super_block *, struct dentry *, struct nfs_mount_info *);
     143                 :            :         struct nfs_parsed_mount_data *parsed;
     144                 :            :         struct nfs_clone_mount *cloned;
     145                 :            :         struct nfs_fh *mntfh;
     146                 :            : };
     147                 :            : 
     148                 :            : extern int nfs_mount(struct nfs_mount_request *info);
     149                 :            : extern void nfs_umount(const struct nfs_mount_request *info);
     150                 :            : 
     151                 :            : /* client.c */
     152                 :            : extern const struct rpc_program nfs_program;
     153                 :            : extern void nfs_clients_init(struct net *net);
     154                 :            : extern void nfs_clients_exit(struct net *net);
     155                 :            : extern struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *);
     156                 :            : int nfs_create_rpc_client(struct nfs_client *, const struct nfs_client_initdata *, rpc_authflavor_t);
     157                 :            : struct nfs_client *nfs_get_client(const struct nfs_client_initdata *);
     158                 :            : int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *, struct nfs_fattr *);
     159                 :            : void nfs_server_insert_lists(struct nfs_server *);
     160                 :            : void nfs_server_remove_lists(struct nfs_server *);
     161                 :            : void nfs_init_timeout_values(struct rpc_timeout *to, int proto, int timeo, int retrans);
     162                 :            : int nfs_init_server_rpcclient(struct nfs_server *, const struct rpc_timeout *t,
     163                 :            :                 rpc_authflavor_t);
     164                 :            : struct nfs_server *nfs_alloc_server(void);
     165                 :            : void nfs_server_copy_userdata(struct nfs_server *, struct nfs_server *);
     166                 :            : 
     167                 :            : extern void nfs_put_client(struct nfs_client *);
     168                 :            : extern void nfs_free_client(struct nfs_client *);
     169                 :            : extern struct nfs_client *nfs4_find_client_ident(struct net *, int);
     170                 :            : extern struct nfs_client *
     171                 :            : nfs4_find_client_sessionid(struct net *, const struct sockaddr *,
     172                 :            :                                 struct nfs4_sessionid *, u32);
     173                 :            : extern struct nfs_server *nfs_create_server(struct nfs_mount_info *,
     174                 :            :                                         struct nfs_subversion *);
     175                 :            : extern struct nfs_server *nfs4_create_server(
     176                 :            :                                         struct nfs_mount_info *,
     177                 :            :                                         struct nfs_subversion *);
     178                 :            : extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
     179                 :            :                                                       struct nfs_fh *);
     180                 :            : extern int nfs4_update_server(struct nfs_server *server, const char *hostname,
     181                 :            :                                         struct sockaddr *sap, size_t salen,
     182                 :            :                                         struct net *net);
     183                 :            : extern void nfs_free_server(struct nfs_server *server);
     184                 :            : extern struct nfs_server *nfs_clone_server(struct nfs_server *,
     185                 :            :                                            struct nfs_fh *,
     186                 :            :                                            struct nfs_fattr *,
     187                 :            :                                            rpc_authflavor_t);
     188                 :            : extern bool nfs_client_init_is_complete(const struct nfs_client *clp);
     189                 :            : extern int nfs_client_init_status(const struct nfs_client *clp);
     190                 :            : extern int nfs_wait_client_init_complete(const struct nfs_client *clp);
     191                 :            : extern void nfs_mark_client_ready(struct nfs_client *clp, int state);
     192                 :            : extern struct nfs_client *nfs4_set_ds_client(struct nfs_server *mds_srv,
     193                 :            :                                              const struct sockaddr *ds_addr,
     194                 :            :                                              int ds_addrlen, int ds_proto,
     195                 :            :                                              unsigned int ds_timeo,
     196                 :            :                                              unsigned int ds_retrans,
     197                 :            :                                              u32 minor_version);
     198                 :            : extern struct rpc_clnt *nfs4_find_or_create_ds_client(struct nfs_client *,
     199                 :            :                                                 struct inode *);
     200                 :            : extern struct nfs_client *nfs3_set_ds_client(struct nfs_server *mds_srv,
     201                 :            :                         const struct sockaddr *ds_addr, int ds_addrlen,
     202                 :            :                         int ds_proto, unsigned int ds_timeo,
     203                 :            :                         unsigned int ds_retrans);
     204                 :            : #ifdef CONFIG_PROC_FS
     205                 :            : extern int __init nfs_fs_proc_init(void);
     206                 :            : extern void nfs_fs_proc_exit(void);
     207                 :            : extern int nfs_fs_proc_net_init(struct net *net);
     208                 :            : extern void nfs_fs_proc_net_exit(struct net *net);
     209                 :            : #else
     210                 :            : static inline int nfs_fs_proc_net_init(struct net *net)
     211                 :            : {
     212                 :            :         return 0;
     213                 :            : }
     214                 :            : static inline void nfs_fs_proc_net_exit(struct net *net)
     215                 :            : {
     216                 :            : }
     217                 :            : static inline int nfs_fs_proc_init(void)
     218                 :            : {
     219                 :            :         return 0;
     220                 :            : }
     221                 :            : static inline void nfs_fs_proc_exit(void)
     222                 :            : {
     223                 :            : }
     224                 :            : #endif
     225                 :            : 
     226                 :            : /* callback_xdr.c */
     227                 :            : extern const struct svc_version nfs4_callback_version1;
     228                 :            : extern const struct svc_version nfs4_callback_version4;
     229                 :            : 
     230                 :            : struct nfs_pageio_descriptor;
     231                 :            : /* pagelist.c */
     232                 :            : extern int __init nfs_init_nfspagecache(void);
     233                 :            : extern void nfs_destroy_nfspagecache(void);
     234                 :            : extern int __init nfs_init_readpagecache(void);
     235                 :            : extern void nfs_destroy_readpagecache(void);
     236                 :            : extern int __init nfs_init_writepagecache(void);
     237                 :            : extern void nfs_destroy_writepagecache(void);
     238                 :            : 
     239                 :            : extern int __init nfs_init_directcache(void);
     240                 :            : extern void nfs_destroy_directcache(void);
     241                 :            : extern void nfs_pgheader_init(struct nfs_pageio_descriptor *desc,
     242                 :            :                               struct nfs_pgio_header *hdr,
     243                 :            :                               void (*release)(struct nfs_pgio_header *hdr));
     244                 :            : void nfs_set_pgio_error(struct nfs_pgio_header *hdr, int error, loff_t pos);
     245                 :            : int nfs_iocounter_wait(struct nfs_lock_context *l_ctx);
     246                 :            : 
     247                 :            : extern const struct nfs_pageio_ops nfs_pgio_rw_ops;
     248                 :            : struct nfs_pgio_header *nfs_pgio_header_alloc(const struct nfs_rw_ops *);
     249                 :            : void nfs_pgio_header_free(struct nfs_pgio_header *);
     250                 :            : int nfs_generic_pgio(struct nfs_pageio_descriptor *, struct nfs_pgio_header *);
     251                 :            : int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr,
     252                 :            :                       const struct cred *cred, const struct nfs_rpc_ops *rpc_ops,
     253                 :            :                       const struct rpc_call_ops *call_ops, int how, int flags);
     254                 :            : void nfs_free_request(struct nfs_page *req);
     255                 :            : struct nfs_pgio_mirror *
     256                 :            : nfs_pgio_current_mirror(struct nfs_pageio_descriptor *desc);
     257                 :            : 
     258                 :          0 : static inline bool nfs_pgio_has_mirroring(struct nfs_pageio_descriptor *desc)
     259                 :            : {
     260   [ #  #  #  # ]:          0 :         WARN_ON_ONCE(desc->pg_mirror_count < 1);
     261                 :          0 :         return desc->pg_mirror_count > 1;
     262                 :            : }
     263                 :            : 
     264                 :          0 : static inline bool nfs_match_open_context(const struct nfs_open_context *ctx1,
     265                 :            :                 const struct nfs_open_context *ctx2)
     266                 :            : {
     267   [ #  #  #  # ]:          0 :         return cred_fscmp(ctx1->cred, ctx2->cred) == 0 && ctx1->state == ctx2->state;
     268                 :            : }
     269                 :            : 
     270                 :            : /* nfs2xdr.c */
     271                 :            : extern const struct rpc_procinfo nfs_procedures[];
     272                 :            : extern int nfs2_decode_dirent(struct xdr_stream *,
     273                 :            :                                 struct nfs_entry *, bool);
     274                 :            : 
     275                 :            : /* nfs3xdr.c */
     276                 :            : extern const struct rpc_procinfo nfs3_procedures[];
     277                 :            : extern int nfs3_decode_dirent(struct xdr_stream *,
     278                 :            :                                 struct nfs_entry *, bool);
     279                 :            : 
     280                 :            : /* nfs4xdr.c */
     281                 :            : #if IS_ENABLED(CONFIG_NFS_V4)
     282                 :            : extern int nfs4_decode_dirent(struct xdr_stream *,
     283                 :            :                                 struct nfs_entry *, bool);
     284                 :            : #endif
     285                 :            : #ifdef CONFIG_NFS_V4_1
     286                 :            : extern const u32 nfs41_maxread_overhead;
     287                 :            : extern const u32 nfs41_maxwrite_overhead;
     288                 :            : extern const u32 nfs41_maxgetdevinfo_overhead;
     289                 :            : #endif
     290                 :            : 
     291                 :            : /* nfs4proc.c */
     292                 :            : #if IS_ENABLED(CONFIG_NFS_V4)
     293                 :            : extern const struct rpc_procinfo nfs4_procedures[];
     294                 :            : #endif
     295                 :            : 
     296                 :            : #ifdef CONFIG_NFS_V4_SECURITY_LABEL
     297                 :            : extern struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags);
     298                 :            : static inline struct nfs4_label *
     299                 :          0 : nfs4_label_copy(struct nfs4_label *dst, struct nfs4_label *src)
     300                 :            : {
     301         [ #  # ]:          0 :         if (!dst || !src)
     302                 :            :                 return NULL;
     303                 :            : 
     304         [ #  # ]:          0 :         if (src->len > NFS4_MAXLABELLEN)
     305                 :            :                 return NULL;
     306                 :            : 
     307                 :          0 :         dst->lfs = src->lfs;
     308                 :          0 :         dst->pi = src->pi;
     309                 :          0 :         dst->len = src->len;
     310                 :          0 :         memcpy(dst->label, src->label, src->len);
     311                 :            : 
     312                 :          0 :         return dst;
     313                 :            : }
     314                 :          0 : static inline void nfs4_label_free(struct nfs4_label *label)
     315                 :            : {
     316         [ #  # ]:          0 :         if (label) {
     317                 :          0 :                 kfree(label->label);
     318                 :          0 :                 kfree(label);
     319                 :            :         }
     320                 :          0 :         return;
     321                 :            : }
     322                 :            : 
     323                 :            : static inline void nfs_zap_label_cache_locked(struct nfs_inode *nfsi)
     324                 :            : {
     325         [ #  # ]:          0 :         if (nfs_server_capable(&nfsi->vfs_inode, NFS_CAP_SECURITY_LABEL))
     326                 :          0 :                 nfsi->cache_validity |= NFS_INO_INVALID_LABEL;
     327                 :            : }
     328                 :            : #else
     329                 :            : static inline struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags) { return NULL; }
     330                 :            : static inline void nfs4_label_free(void *label) {}
     331                 :            : static inline void nfs_zap_label_cache_locked(struct nfs_inode *nfsi)
     332                 :            : {
     333                 :            : }
     334                 :            : static inline struct nfs4_label *
     335                 :            : nfs4_label_copy(struct nfs4_label *dst, struct nfs4_label *src)
     336                 :            : {
     337                 :            :         return NULL;
     338                 :            : }
     339                 :            : #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
     340                 :            : 
     341                 :            : /* proc.c */
     342                 :            : void nfs_close_context(struct nfs_open_context *ctx, int is_sync);
     343                 :            : extern struct nfs_client *nfs_init_client(struct nfs_client *clp,
     344                 :            :                            const struct nfs_client_initdata *);
     345                 :            : 
     346                 :            : /* dir.c */
     347                 :            : extern void nfs_advise_use_readdirplus(struct inode *dir);
     348                 :            : extern void nfs_force_use_readdirplus(struct inode *dir);
     349                 :            : extern unsigned long nfs_access_cache_count(struct shrinker *shrink,
     350                 :            :                                             struct shrink_control *sc);
     351                 :            : extern unsigned long nfs_access_cache_scan(struct shrinker *shrink,
     352                 :            :                                            struct shrink_control *sc);
     353                 :            : struct dentry *nfs_lookup(struct inode *, struct dentry *, unsigned int);
     354                 :            : int nfs_create(struct inode *, struct dentry *, umode_t, bool);
     355                 :            : int nfs_mkdir(struct inode *, struct dentry *, umode_t);
     356                 :            : int nfs_rmdir(struct inode *, struct dentry *);
     357                 :            : int nfs_unlink(struct inode *, struct dentry *);
     358                 :            : int nfs_symlink(struct inode *, struct dentry *, const char *);
     359                 :            : int nfs_link(struct dentry *, struct inode *, struct dentry *);
     360                 :            : int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
     361                 :            : int nfs_rename(struct inode *, struct dentry *,
     362                 :            :                struct inode *, struct dentry *, unsigned int);
     363                 :            : 
     364                 :            : /* file.c */
     365                 :            : int nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync);
     366                 :            : loff_t nfs_file_llseek(struct file *, loff_t, int);
     367                 :            : ssize_t nfs_file_read(struct kiocb *, struct iov_iter *);
     368                 :            : int nfs_file_mmap(struct file *, struct vm_area_struct *);
     369                 :            : ssize_t nfs_file_write(struct kiocb *, struct iov_iter *);
     370                 :            : int nfs_file_release(struct inode *, struct file *);
     371                 :            : int nfs_lock(struct file *, int, struct file_lock *);
     372                 :            : int nfs_flock(struct file *, int, struct file_lock *);
     373                 :            : int nfs_check_flags(int);
     374                 :            : 
     375                 :            : /* inode.c */
     376                 :            : extern struct workqueue_struct *nfsiod_workqueue;
     377                 :            : extern struct inode *nfs_alloc_inode(struct super_block *sb);
     378                 :            : extern void nfs_free_inode(struct inode *);
     379                 :            : extern int nfs_write_inode(struct inode *, struct writeback_control *);
     380                 :            : extern int nfs_drop_inode(struct inode *);
     381                 :            : extern void nfs_clear_inode(struct inode *);
     382                 :            : extern void nfs_evict_inode(struct inode *);
     383                 :            : void nfs_zap_acl_cache(struct inode *inode);
     384                 :            : extern bool nfs_check_cache_invalid(struct inode *, unsigned long);
     385                 :            : extern int nfs_wait_bit_killable(struct wait_bit_key *key, int mode);
     386                 :            : extern int nfs_wait_atomic_killable(atomic_t *p, unsigned int mode);
     387                 :            : 
     388                 :            : /* super.c */
     389                 :            : extern const struct super_operations nfs_sops;
     390                 :            : extern struct file_system_type nfs_fs_type;
     391                 :            : extern struct file_system_type nfs_xdev_fs_type;
     392                 :            : #if IS_ENABLED(CONFIG_NFS_V4)
     393                 :            : extern struct file_system_type nfs4_referral_fs_type;
     394                 :            : #endif
     395                 :            : bool nfs_auth_info_match(const struct nfs_auth_info *, rpc_authflavor_t);
     396                 :            : struct dentry *nfs_try_mount(int, const char *, struct nfs_mount_info *,
     397                 :            :                         struct nfs_subversion *);
     398                 :            : int nfs_set_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
     399                 :            : int nfs_clone_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
     400                 :            : struct dentry *nfs_fs_mount_common(struct nfs_server *, int, const char *,
     401                 :            :                                    struct nfs_mount_info *, struct nfs_subversion *);
     402                 :            : struct dentry *nfs_fs_mount(struct file_system_type *, int, const char *, void *);
     403                 :            : struct dentry * nfs_xdev_mount_common(struct file_system_type *, int,
     404                 :            :                 const char *, struct nfs_mount_info *);
     405                 :            : void nfs_kill_super(struct super_block *);
     406                 :            : void nfs_fill_super(struct super_block *, struct nfs_mount_info *);
     407                 :            : 
     408                 :            : extern struct rpc_stat nfs_rpcstat;
     409                 :            : 
     410                 :            : extern int __init register_nfs_fs(void);
     411                 :            : extern void __exit unregister_nfs_fs(void);
     412                 :            : extern bool nfs_sb_active(struct super_block *sb);
     413                 :            : extern void nfs_sb_deactive(struct super_block *sb);
     414                 :            : 
     415                 :            : /* io.c */
     416                 :            : extern void nfs_start_io_read(struct inode *inode);
     417                 :            : extern void nfs_end_io_read(struct inode *inode);
     418                 :            : extern void nfs_start_io_write(struct inode *inode);
     419                 :            : extern void nfs_end_io_write(struct inode *inode);
     420                 :            : extern void nfs_start_io_direct(struct inode *inode);
     421                 :            : extern void nfs_end_io_direct(struct inode *inode);
     422                 :            : 
     423                 :            : static inline bool nfs_file_io_is_buffered(struct nfs_inode *nfsi)
     424                 :            : {
     425                 :            :         return test_bit(NFS_INO_ODIRECT, &nfsi->flags) == 0;
     426                 :            : }
     427                 :            : 
     428                 :            : /* namespace.c */
     429                 :            : #define NFS_PATH_CANONICAL 1
     430                 :            : extern char *nfs_path(char **p, struct dentry *dentry,
     431                 :            :                       char *buffer, ssize_t buflen, unsigned flags);
     432                 :            : extern struct vfsmount *nfs_d_automount(struct path *path);
     433                 :            : struct vfsmount *nfs_submount(struct nfs_server *, struct dentry *,
     434                 :            :                               struct nfs_fh *, struct nfs_fattr *);
     435                 :            : struct vfsmount *nfs_do_submount(struct dentry *, struct nfs_fh *,
     436                 :            :                                  struct nfs_fattr *, rpc_authflavor_t);
     437                 :            : 
     438                 :            : /* getroot.c */
     439                 :            : extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *,
     440                 :            :                                    const char *);
     441                 :            : #if IS_ENABLED(CONFIG_NFS_V4)
     442                 :            : extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *,
     443                 :            :                                     const char *);
     444                 :            : 
     445                 :            : extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh, bool);
     446                 :            : #endif
     447                 :            : 
     448                 :            : struct nfs_pgio_completion_ops;
     449                 :            : /* read.c */
     450                 :            : extern void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio,
     451                 :            :                         struct inode *inode, bool force_mds,
     452                 :            :                         const struct nfs_pgio_completion_ops *compl_ops);
     453                 :            : extern void nfs_read_prepare(struct rpc_task *task, void *calldata);
     454                 :            : extern void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio);
     455                 :            : 
     456                 :            : /* super.c */
     457                 :            : void nfs_umount_begin(struct super_block *);
     458                 :            : int  nfs_statfs(struct dentry *, struct kstatfs *);
     459                 :            : int  nfs_show_options(struct seq_file *, struct dentry *);
     460                 :            : int  nfs_show_devname(struct seq_file *, struct dentry *);
     461                 :            : int  nfs_show_path(struct seq_file *, struct dentry *);
     462                 :            : int  nfs_show_stats(struct seq_file *, struct dentry *);
     463                 :            : int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
     464                 :            : 
     465                 :            : /* write.c */
     466                 :            : extern void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
     467                 :            :                         struct inode *inode, int ioflags, bool force_mds,
     468                 :            :                         const struct nfs_pgio_completion_ops *compl_ops);
     469                 :            : extern void nfs_pageio_reset_write_mds(struct nfs_pageio_descriptor *pgio);
     470                 :            : extern void nfs_commit_free(struct nfs_commit_data *p);
     471                 :            : extern void nfs_write_prepare(struct rpc_task *task, void *calldata);
     472                 :            : extern void nfs_commit_prepare(struct rpc_task *task, void *calldata);
     473                 :            : extern int nfs_initiate_commit(struct rpc_clnt *clnt,
     474                 :            :                                struct nfs_commit_data *data,
     475                 :            :                                const struct nfs_rpc_ops *nfs_ops,
     476                 :            :                                const struct rpc_call_ops *call_ops,
     477                 :            :                                int how, int flags);
     478                 :            : extern void nfs_init_commit(struct nfs_commit_data *data,
     479                 :            :                             struct list_head *head,
     480                 :            :                             struct pnfs_layout_segment *lseg,
     481                 :            :                             struct nfs_commit_info *cinfo);
     482                 :            : int nfs_scan_commit_list(struct list_head *src, struct list_head *dst,
     483                 :            :                          struct nfs_commit_info *cinfo, int max);
     484                 :            : unsigned long nfs_reqs_to_commit(struct nfs_commit_info *);
     485                 :            : int nfs_scan_commit(struct inode *inode, struct list_head *dst,
     486                 :            :                     struct nfs_commit_info *cinfo);
     487                 :            : void nfs_mark_request_commit(struct nfs_page *req,
     488                 :            :                              struct pnfs_layout_segment *lseg,
     489                 :            :                              struct nfs_commit_info *cinfo,
     490                 :            :                              u32 ds_commit_idx);
     491                 :            : int nfs_write_need_commit(struct nfs_pgio_header *);
     492                 :            : void nfs_writeback_update_inode(struct nfs_pgio_header *hdr);
     493                 :            : int nfs_generic_commit_list(struct inode *inode, struct list_head *head,
     494                 :            :                             int how, struct nfs_commit_info *cinfo);
     495                 :            : void nfs_retry_commit(struct list_head *page_list,
     496                 :            :                       struct pnfs_layout_segment *lseg,
     497                 :            :                       struct nfs_commit_info *cinfo,
     498                 :            :                       u32 ds_commit_idx);
     499                 :            : void nfs_commitdata_release(struct nfs_commit_data *data);
     500                 :            : void nfs_request_add_commit_list(struct nfs_page *req,
     501                 :            :                                  struct nfs_commit_info *cinfo);
     502                 :            : void nfs_request_add_commit_list_locked(struct nfs_page *req,
     503                 :            :                 struct list_head *dst,
     504                 :            :                 struct nfs_commit_info *cinfo);
     505                 :            : void nfs_request_remove_commit_list(struct nfs_page *req,
     506                 :            :                                     struct nfs_commit_info *cinfo);
     507                 :            : void nfs_init_cinfo(struct nfs_commit_info *cinfo,
     508                 :            :                     struct inode *inode,
     509                 :            :                     struct nfs_direct_req *dreq);
     510                 :            : int nfs_key_timeout_notify(struct file *filp, struct inode *inode);
     511                 :            : bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx, struct inode *inode);
     512                 :            : void nfs_pageio_stop_mirroring(struct nfs_pageio_descriptor *pgio);
     513                 :            : 
     514                 :            : int nfs_filemap_write_and_wait_range(struct address_space *mapping,
     515                 :            :                 loff_t lstart, loff_t lend);
     516                 :            : 
     517                 :            : #ifdef CONFIG_NFS_V4_1
     518                 :            : static inline
     519                 :            : void nfs_clear_pnfs_ds_commit_verifiers(struct pnfs_ds_commit_info *cinfo)
     520                 :            : {
     521                 :            :         int i;
     522                 :            : 
     523         [ #  # ]:          0 :         for (i = 0; i < cinfo->nbuckets; i++)
     524                 :          0 :                 cinfo->buckets[i].direct_verf.committed = NFS_INVALID_STABLE_HOW;
     525                 :            : }
     526                 :            : #else
     527                 :            : static inline
     528                 :            : void nfs_clear_pnfs_ds_commit_verifiers(struct pnfs_ds_commit_info *cinfo)
     529                 :            : {
     530                 :            : }
     531                 :            : #endif
     532                 :            : 
     533                 :            : #ifdef CONFIG_MIGRATION
     534                 :            : extern int nfs_migrate_page(struct address_space *,
     535                 :            :                 struct page *, struct page *, enum migrate_mode);
     536                 :            : #endif
     537                 :            : 
     538                 :            : static inline int
     539                 :            : nfs_write_verifier_cmp(const struct nfs_write_verifier *v1,
     540                 :            :                 const struct nfs_write_verifier *v2)
     541                 :            : {
     542                 :          0 :         return memcmp(v1->data, v2->data, sizeof(v1->data));
     543                 :            : }
     544                 :            : 
     545                 :            : /* unlink.c */
     546                 :            : extern struct rpc_task *
     547                 :            : nfs_async_rename(struct inode *old_dir, struct inode *new_dir,
     548                 :            :                  struct dentry *old_dentry, struct dentry *new_dentry,
     549                 :            :                  void (*complete)(struct rpc_task *, struct nfs_renamedata *));
     550                 :            : extern int nfs_sillyrename(struct inode *dir, struct dentry *dentry);
     551                 :            : 
     552                 :            : /* direct.c */
     553                 :            : void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo,
     554                 :            :                               struct nfs_direct_req *dreq);
     555                 :            : extern ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq);
     556                 :            : 
     557                 :            : /* nfs4proc.c */
     558                 :            : extern struct nfs_client *nfs4_init_client(struct nfs_client *clp,
     559                 :            :                             const struct nfs_client_initdata *);
     560                 :            : extern int nfs40_walk_client_list(struct nfs_client *clp,
     561                 :            :                                 struct nfs_client **result,
     562                 :            :                                 const struct cred *cred);
     563                 :            : extern int nfs41_walk_client_list(struct nfs_client *clp,
     564                 :            :                                 struct nfs_client **result,
     565                 :            :                                 const struct cred *cred);
     566                 :            : extern void nfs4_test_session_trunk(struct rpc_clnt *clnt,
     567                 :            :                                 struct rpc_xprt *xprt,
     568                 :            :                                 void *data);
     569                 :            : 
     570                 :          0 : static inline struct inode *nfs_igrab_and_active(struct inode *inode)
     571                 :            : {
     572                 :          0 :         inode = igrab(inode);
     573   [ #  #  #  # ]:          0 :         if (inode != NULL && !nfs_sb_active(inode->i_sb)) {
     574                 :          0 :                 iput(inode);
     575                 :            :                 inode = NULL;
     576                 :            :         }
     577                 :          0 :         return inode;
     578                 :            : }
     579                 :            : 
     580                 :          0 : static inline void nfs_iput_and_deactive(struct inode *inode)
     581                 :            : {
     582         [ #  # ]:          0 :         if (inode != NULL) {
     583                 :          0 :                 struct super_block *sb = inode->i_sb;
     584                 :            : 
     585                 :          0 :                 iput(inode);
     586                 :          0 :                 nfs_sb_deactive(sb);
     587                 :            :         }
     588                 :          0 : }
     589                 :            : 
     590                 :            : /*
     591                 :            :  * Determine the device name as a string
     592                 :            :  */
     593                 :            : static inline char *nfs_devname(struct dentry *dentry,
     594                 :            :                                 char *buffer, ssize_t buflen)
     595                 :            : {
     596                 :            :         char *dummy;
     597                 :          0 :         return nfs_path(&dummy, dentry, buffer, buflen, NFS_PATH_CANONICAL);
     598                 :            : }
     599                 :            : 
     600                 :            : /*
     601                 :            :  * Determine the actual block size (and log2 thereof)
     602                 :            :  */
     603                 :            : static inline
     604                 :          0 : unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
     605                 :            : {
     606                 :            :         /* make sure blocksize is a power of two */
     607   [ #  #  #  # ]:          0 :         if ((bsize & (bsize - 1)) || nrbitsp) {
     608                 :            :                 unsigned char   nrbits;
     609                 :            : 
     610   [ #  #  #  # ]:          0 :                 for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
     611                 :            :                         ;
     612                 :          0 :                 bsize = 1 << nrbits;
     613         [ #  # ]:          0 :                 if (nrbitsp)
     614                 :          0 :                         *nrbitsp = nrbits;
     615                 :            :         }
     616                 :            : 
     617                 :          0 :         return bsize;
     618                 :            : }
     619                 :            : 
     620                 :            : /*
     621                 :            :  * Calculate the number of 512byte blocks used.
     622                 :            :  */
     623                 :            : static inline blkcnt_t nfs_calc_block_size(u64 tsize)
     624                 :            : {
     625                 :          0 :         blkcnt_t used = (tsize + 511) >> 9;
     626                 :          0 :         return (used > ULONG_MAX) ? ULONG_MAX : used;
     627                 :            : }
     628                 :            : 
     629                 :            : /*
     630                 :            :  * Compute and set NFS server blocksize
     631                 :            :  */
     632                 :            : static inline
     633                 :            : unsigned long nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
     634                 :            : {
     635   [ #  #  #  #  :          0 :         if (bsize < NFS_MIN_FILE_IO_SIZE)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     636                 :            :                 bsize = NFS_DEF_FILE_IO_SIZE;
     637   [ #  #  #  #  :          0 :         else if (bsize >= NFS_MAX_FILE_IO_SIZE)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     638                 :            :                 bsize = NFS_MAX_FILE_IO_SIZE;
     639                 :            : 
     640                 :          0 :         return nfs_block_bits(bsize, nrbitsp);
     641                 :            : }
     642                 :            : 
     643                 :            : /*
     644                 :            :  * Determine the maximum file size for a superblock
     645                 :            :  */
     646                 :            : static inline
     647                 :            : void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
     648                 :            : {
     649                 :          0 :         sb->s_maxbytes = (loff_t)maxfilesize;
     650         [ #  # ]:          0 :         if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
     651                 :          0 :                 sb->s_maxbytes = MAX_LFS_FILESIZE;
     652                 :            : }
     653                 :            : 
     654                 :            : /*
     655                 :            :  * Record the page as unstable and mark its inode as dirty.
     656                 :            :  */
     657                 :            : static inline
     658                 :          0 : void nfs_mark_page_unstable(struct page *page, struct nfs_commit_info *cinfo)
     659                 :            : {
     660         [ #  # ]:          0 :         if (!cinfo->dreq) {
     661                 :          0 :                 struct inode *inode = page_file_mapping(page)->host;
     662                 :            : 
     663                 :          0 :                 inc_node_page_state(page, NR_UNSTABLE_NFS);
     664                 :          0 :                 inc_wb_stat(&inode_to_bdi(inode)->wb, WB_RECLAIMABLE);
     665                 :          0 :                 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
     666                 :            :         }
     667                 :          0 : }
     668                 :            : 
     669                 :            : /*
     670                 :            :  * Determine the number of bytes of data the page contains
     671                 :            :  */
     672                 :            : static inline
     673                 :          0 : unsigned int nfs_page_length(struct page *page)
     674                 :            : {
     675                 :          0 :         loff_t i_size = i_size_read(page_file_mapping(page)->host);
     676                 :            : 
     677         [ #  # ]:          0 :         if (i_size > 0) {
     678                 :          0 :                 pgoff_t index = page_index(page);
     679                 :          0 :                 pgoff_t end_index = (i_size - 1) >> PAGE_SHIFT;
     680         [ #  # ]:          0 :                 if (index < end_index)
     681                 :            :                         return PAGE_SIZE;
     682         [ #  # ]:          0 :                 if (index == end_index)
     683                 :          0 :                         return ((i_size - 1) & ~PAGE_MASK) + 1;
     684                 :            :         }
     685                 :            :         return 0;
     686                 :            : }
     687                 :            : 
     688                 :            : /*
     689                 :            :  * Convert a umode to a dirent->d_type
     690                 :            :  */
     691                 :            : static inline
     692                 :            : unsigned char nfs_umode_to_dtype(umode_t mode)
     693                 :            : {
     694                 :          0 :         return (mode >> 12) & 15;
     695                 :            : }
     696                 :            : 
     697                 :            : /*
     698                 :            :  * Determine the number of pages in an array of length 'len' and
     699                 :            :  * with a base offset of 'base'
     700                 :            :  */
     701                 :            : static inline
     702                 :            : unsigned int nfs_page_array_len(unsigned int base, size_t len)
     703                 :            : {
     704                 :          0 :         return ((unsigned long)len + (unsigned long)base +
     705                 :          0 :                 PAGE_SIZE - 1) >> PAGE_SHIFT;
     706                 :            : }
     707                 :            : 
     708                 :            : /*
     709                 :            :  * Convert a struct timespec into a 64-bit change attribute
     710                 :            :  *
     711                 :            :  * This does approximately the same thing as timespec_to_ns(),
     712                 :            :  * but for calculation efficiency, we multiply the seconds by
     713                 :            :  * 1024*1024*1024.
     714                 :            :  */
     715                 :            : static inline
     716                 :            : u64 nfs_timespec_to_change_attr(const struct timespec *ts)
     717                 :            : {
     718                 :          0 :         return ((u64)ts->tv_sec << 30) + ts->tv_nsec;
     719                 :            : }
     720                 :            : 
     721                 :            : #ifdef CONFIG_CRC32
     722                 :            : /**
     723                 :            :  * nfs_fhandle_hash - calculate the crc32 hash for the filehandle
     724                 :            :  * @fh - pointer to filehandle
     725                 :            :  *
     726                 :            :  * returns a crc32 hash for the filehandle that is compatible with
     727                 :            :  * the one displayed by "wireshark".
     728                 :            :  */
     729                 :            : static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
     730                 :            : {
     731                 :          0 :         return ~crc32_le(0xFFFFFFFF, &fh->data[0], fh->size);
     732                 :            : }
     733                 :            : static inline u32 nfs_stateid_hash(const nfs4_stateid *stateid)
     734                 :            : {
     735                 :          0 :         return ~crc32_le(0xFFFFFFFF, &stateid->other[0],
     736                 :            :                                 NFS4_STATEID_OTHER_SIZE);
     737                 :            : }
     738                 :            : #else
     739                 :            : static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
     740                 :            : {
     741                 :            :         return 0;
     742                 :            : }
     743                 :            : static inline u32 nfs_stateid_hash(nfs4_stateid *stateid)
     744                 :            : {
     745                 :            :         return 0;
     746                 :            : }
     747                 :            : #endif
     748                 :            : 
     749                 :          0 : static inline bool nfs_error_is_fatal(int err)
     750                 :            : {
     751         [ #  # ]:          0 :         switch (err) {
     752                 :            :         case -ERESTARTSYS:
     753                 :            :         case -EINTR:
     754                 :            :         case -EACCES:
     755                 :            :         case -EDQUOT:
     756                 :            :         case -EFBIG:
     757                 :            :         case -EIO:
     758                 :            :         case -ENOSPC:
     759                 :            :         case -EROFS:
     760                 :            :         case -ESTALE:
     761                 :            :         case -E2BIG:
     762                 :            :         case -ENOMEM:
     763                 :            :         case -ETIMEDOUT:
     764                 :            :                 return true;
     765                 :            :         default:
     766                 :          0 :                 return false;
     767                 :            :         }
     768                 :            : }
     769                 :            : 
     770                 :          0 : static inline bool nfs_error_is_fatal_on_server(int err)
     771                 :            : {
     772         [ #  # ]:          0 :         switch (err) {
     773                 :            :         case 0:
     774                 :            :         case -ERESTARTSYS:
     775                 :            :         case -EINTR:
     776                 :            :                 return false;
     777                 :            :         }
     778                 :          0 :         return nfs_error_is_fatal(err);
     779                 :            : }

Generated by: LCOV version 1.14