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

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * linux/fs/nfs/nfs4_fs.h
       4                 :            :  *
       5                 :            :  * Copyright (C) 2005 Trond Myklebust
       6                 :            :  *
       7                 :            :  * NFSv4-specific filesystem definitions and declarations
       8                 :            :  */
       9                 :            : 
      10                 :            : #ifndef __LINUX_FS_NFS_NFS4_FS_H
      11                 :            : #define __LINUX_FS_NFS_NFS4_FS_H
      12                 :            : 
      13                 :            : #if defined(CONFIG_NFS_V4_2)
      14                 :            : #define NFS4_MAX_MINOR_VERSION 2
      15                 :            : #elif defined(CONFIG_NFS_V4_1)
      16                 :            : #define NFS4_MAX_MINOR_VERSION 1
      17                 :            : #else
      18                 :            : #define NFS4_MAX_MINOR_VERSION 0
      19                 :            : #endif
      20                 :            : 
      21                 :            : #if IS_ENABLED(CONFIG_NFS_V4)
      22                 :            : 
      23                 :            : #define NFS4_MAX_LOOP_ON_RECOVER (10)
      24                 :            : 
      25                 :            : #include <linux/seqlock.h>
      26                 :            : 
      27                 :            : struct idmap;
      28                 :            : 
      29                 :            : enum nfs4_client_state {
      30                 :            :         NFS4CLNT_MANAGER_RUNNING  = 0,
      31                 :            :         NFS4CLNT_CHECK_LEASE,
      32                 :            :         NFS4CLNT_LEASE_EXPIRED,
      33                 :            :         NFS4CLNT_RECLAIM_REBOOT,
      34                 :            :         NFS4CLNT_RECLAIM_NOGRACE,
      35                 :            :         NFS4CLNT_DELEGRETURN,
      36                 :            :         NFS4CLNT_SESSION_RESET,
      37                 :            :         NFS4CLNT_LEASE_CONFIRM,
      38                 :            :         NFS4CLNT_SERVER_SCOPE_MISMATCH,
      39                 :            :         NFS4CLNT_PURGE_STATE,
      40                 :            :         NFS4CLNT_BIND_CONN_TO_SESSION,
      41                 :            :         NFS4CLNT_MOVED,
      42                 :            :         NFS4CLNT_LEASE_MOVED,
      43                 :            :         NFS4CLNT_DELEGATION_EXPIRED,
      44                 :            :         NFS4CLNT_RUN_MANAGER,
      45                 :            :         NFS4CLNT_DELEGRETURN_RUNNING,
      46                 :            : };
      47                 :            : 
      48                 :            : #define NFS4_RENEW_TIMEOUT              0x01
      49                 :            : #define NFS4_RENEW_DELEGATION_CB        0x02
      50                 :            : 
      51                 :            : struct nfs_seqid_counter;
      52                 :            : struct nfs4_minor_version_ops {
      53                 :            :         u32     minor_version;
      54                 :            :         unsigned init_caps;
      55                 :            : 
      56                 :            :         int     (*init_client)(struct nfs_client *);
      57                 :            :         void    (*shutdown_client)(struct nfs_client *);
      58                 :            :         bool    (*match_stateid)(const nfs4_stateid *,
      59                 :            :                         const nfs4_stateid *);
      60                 :            :         int     (*find_root_sec)(struct nfs_server *, struct nfs_fh *,
      61                 :            :                         struct nfs_fsinfo *);
      62                 :            :         void    (*free_lock_state)(struct nfs_server *,
      63                 :            :                         struct nfs4_lock_state *);
      64                 :            :         int     (*test_and_free_expired)(struct nfs_server *,
      65                 :            :                         nfs4_stateid *, const struct cred *);
      66                 :            :         struct nfs_seqid *
      67                 :            :                 (*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
      68                 :            :         void    (*session_trunk)(struct rpc_clnt *clnt,
      69                 :            :                         struct rpc_xprt *xprt, void *data);
      70                 :            :         const struct rpc_call_ops *call_sync_ops;
      71                 :            :         const struct nfs4_state_recovery_ops *reboot_recovery_ops;
      72                 :            :         const struct nfs4_state_recovery_ops *nograce_recovery_ops;
      73                 :            :         const struct nfs4_state_maintenance_ops *state_renewal_ops;
      74                 :            :         const struct nfs4_mig_recovery_ops *mig_recovery_ops;
      75                 :            : };
      76                 :            : 
      77                 :            : #define NFS_SEQID_CONFIRMED 1
      78                 :            : struct nfs_seqid_counter {
      79                 :            :         ktime_t create_time;
      80                 :            :         int owner_id;
      81                 :            :         int flags;
      82                 :            :         u32 counter;
      83                 :            :         spinlock_t lock;                /* Protects the list */
      84                 :            :         struct list_head list;          /* Defines sequence of RPC calls */
      85                 :            :         struct rpc_wait_queue   wait;   /* RPC call delay queue */
      86                 :            : };
      87                 :            : 
      88                 :            : struct nfs_seqid {
      89                 :            :         struct nfs_seqid_counter *sequence;
      90                 :            :         struct list_head list;
      91                 :            :         struct rpc_task *task;
      92                 :            : };
      93                 :            : 
      94                 :          0 : static inline void nfs_confirm_seqid(struct nfs_seqid_counter *seqid, int status)
      95                 :            : {
      96         [ #  # ]:          0 :         if (seqid_mutating_err(-status))
      97                 :          0 :                 seqid->flags |= NFS_SEQID_CONFIRMED;
      98                 :          0 : }
      99                 :            : 
     100                 :            : /*
     101                 :            :  * NFS4 state_owners and lock_owners are simply labels for ordered
     102                 :            :  * sequences of RPC calls. Their sole purpose is to provide once-only
     103                 :            :  * semantics by allowing the server to identify replayed requests.
     104                 :            :  */
     105                 :            : struct nfs4_state_owner {
     106                 :            :         struct nfs_server    *so_server;
     107                 :            :         struct list_head     so_lru;
     108                 :            :         unsigned long        so_expires;
     109                 :            :         struct rb_node       so_server_node;
     110                 :            : 
     111                 :            :         const struct cred    *so_cred;   /* Associated cred */
     112                 :            : 
     113                 :            :         spinlock_t           so_lock;
     114                 :            :         atomic_t             so_count;
     115                 :            :         unsigned long        so_flags;
     116                 :            :         struct list_head     so_states;
     117                 :            :         struct nfs_seqid_counter so_seqid;
     118                 :            :         seqcount_t           so_reclaim_seqcount;
     119                 :            :         struct mutex         so_delegreturn_mutex;
     120                 :            : };
     121                 :            : 
     122                 :            : enum {
     123                 :            :         NFS_OWNER_RECLAIM_REBOOT,
     124                 :            :         NFS_OWNER_RECLAIM_NOGRACE
     125                 :            : };
     126                 :            : 
     127                 :            : #define NFS_LOCK_NEW            0
     128                 :            : #define NFS_LOCK_RECLAIM        1
     129                 :            : #define NFS_LOCK_EXPIRED        2
     130                 :            : 
     131                 :            : /*
     132                 :            :  * struct nfs4_state maintains the client-side state for a given
     133                 :            :  * (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
     134                 :            :  *
     135                 :            :  * OPEN:
     136                 :            :  * In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
     137                 :            :  * we need to know how many files are open for reading or writing on a
     138                 :            :  * given inode. This information too is stored here.
     139                 :            :  *
     140                 :            :  * LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
     141                 :            :  */
     142                 :            : 
     143                 :            : struct nfs4_lock_state {
     144                 :            :         struct list_head        ls_locks;       /* Other lock stateids */
     145                 :            :         struct nfs4_state *     ls_state;       /* Pointer to open state */
     146                 :            : #define NFS_LOCK_INITIALIZED 0
     147                 :            : #define NFS_LOCK_LOST        1
     148                 :            :         unsigned long           ls_flags;
     149                 :            :         struct nfs_seqid_counter        ls_seqid;
     150                 :            :         nfs4_stateid            ls_stateid;
     151                 :            :         refcount_t              ls_count;
     152                 :            :         fl_owner_t              ls_owner;
     153                 :            : };
     154                 :            : 
     155                 :            : /* bits for nfs4_state->flags */
     156                 :            : enum {
     157                 :            :         LK_STATE_IN_USE,
     158                 :            :         NFS_DELEGATED_STATE,            /* Current stateid is delegation */
     159                 :            :         NFS_OPEN_STATE,                 /* OPEN stateid is set */
     160                 :            :         NFS_O_RDONLY_STATE,             /* OPEN stateid has read-only state */
     161                 :            :         NFS_O_WRONLY_STATE,             /* OPEN stateid has write-only state */
     162                 :            :         NFS_O_RDWR_STATE,               /* OPEN stateid has read/write state */
     163                 :            :         NFS_STATE_RECLAIM_REBOOT,       /* OPEN stateid server rebooted */
     164                 :            :         NFS_STATE_RECLAIM_NOGRACE,      /* OPEN stateid needs to recover state */
     165                 :            :         NFS_STATE_POSIX_LOCKS,          /* Posix locks are supported */
     166                 :            :         NFS_STATE_RECOVERY_FAILED,      /* OPEN stateid state recovery failed */
     167                 :            :         NFS_STATE_MAY_NOTIFY_LOCK,      /* server may CB_NOTIFY_LOCK */
     168                 :            :         NFS_STATE_CHANGE_WAIT,          /* A state changing operation is outstanding */
     169                 :            : #ifdef CONFIG_NFS_V4_2
     170                 :            :         NFS_CLNT_DST_SSC_COPY_STATE,    /* dst server open state on client*/
     171                 :            : #endif /* CONFIG_NFS_V4_2 */
     172                 :            : };
     173                 :            : 
     174                 :            : struct nfs4_state {
     175                 :            :         struct list_head open_states;   /* List of states for the same state_owner */
     176                 :            :         struct list_head inode_states;  /* List of states for the same inode */
     177                 :            :         struct list_head lock_states;   /* List of subservient lock stateids */
     178                 :            : 
     179                 :            :         struct nfs4_state_owner *owner; /* Pointer to the open owner */
     180                 :            :         struct inode *inode;            /* Pointer to the inode */
     181                 :            : 
     182                 :            :         unsigned long flags;            /* Do we hold any locks? */
     183                 :            :         spinlock_t state_lock;          /* Protects the lock_states list */
     184                 :            : 
     185                 :            :         seqlock_t seqlock;              /* Protects the stateid/open_stateid */
     186                 :            :         nfs4_stateid stateid;           /* Current stateid: may be delegation */
     187                 :            :         nfs4_stateid open_stateid;      /* OPEN stateid */
     188                 :            : 
     189                 :            :         /* The following 3 fields are protected by owner->so_lock */
     190                 :            :         unsigned int n_rdonly;          /* Number of read-only references */
     191                 :            :         unsigned int n_wronly;          /* Number of write-only references */
     192                 :            :         unsigned int n_rdwr;            /* Number of read/write references */
     193                 :            :         fmode_t state;                  /* State on the server (R,W, or RW) */
     194                 :            :         refcount_t count;
     195                 :            : 
     196                 :            :         wait_queue_head_t waitq;
     197                 :            :         struct rcu_head rcu_head;
     198                 :            : };
     199                 :            : 
     200                 :            : 
     201                 :            : struct nfs4_exception {
     202                 :            :         struct nfs4_state *state;
     203                 :            :         struct inode *inode;
     204                 :            :         nfs4_stateid *stateid;
     205                 :            :         long timeout;
     206                 :            :         unsigned char delay : 1,
     207                 :            :                       recovering : 1,
     208                 :            :                       retry : 1;
     209                 :            :         bool interruptible;
     210                 :            : };
     211                 :            : 
     212                 :            : struct nfs4_state_recovery_ops {
     213                 :            :         int owner_flag_bit;
     214                 :            :         int state_flag_bit;
     215                 :            :         int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *);
     216                 :            :         int (*recover_lock)(struct nfs4_state *, struct file_lock *);
     217                 :            :         int (*establish_clid)(struct nfs_client *, const struct cred *);
     218                 :            :         int (*reclaim_complete)(struct nfs_client *, const struct cred *);
     219                 :            :         int (*detect_trunking)(struct nfs_client *, struct nfs_client **,
     220                 :            :                 const struct cred *);
     221                 :            : };
     222                 :            : 
     223                 :            : struct nfs4_opendata {
     224                 :            :         struct kref kref;
     225                 :            :         struct nfs_openargs o_arg;
     226                 :            :         struct nfs_openres o_res;
     227                 :            :         struct nfs_open_confirmargs c_arg;
     228                 :            :         struct nfs_open_confirmres c_res;
     229                 :            :         struct nfs4_string owner_name;
     230                 :            :         struct nfs4_string group_name;
     231                 :            :         struct nfs4_label *a_label;
     232                 :            :         struct nfs_fattr f_attr;
     233                 :            :         struct nfs4_label *f_label;
     234                 :            :         struct dentry *dir;
     235                 :            :         struct dentry *dentry;
     236                 :            :         struct nfs4_state_owner *owner;
     237                 :            :         struct nfs4_state *state;
     238                 :            :         struct iattr attrs;
     239                 :            :         struct nfs4_layoutget *lgp;
     240                 :            :         unsigned long timestamp;
     241                 :            :         bool rpc_done;
     242                 :            :         bool file_created;
     243                 :            :         bool is_recover;
     244                 :            :         bool cancelled;
     245                 :            :         int rpc_status;
     246                 :            : };
     247                 :            : 
     248                 :            : struct nfs4_add_xprt_data {
     249                 :            :         struct nfs_client       *clp;
     250                 :            :         const struct cred       *cred;
     251                 :            : };
     252                 :            : 
     253                 :            : struct nfs4_state_maintenance_ops {
     254                 :            :         int (*sched_state_renewal)(struct nfs_client *, const struct cred *, unsigned);
     255                 :            :         const struct cred * (*get_state_renewal_cred)(struct nfs_client *);
     256                 :            :         int (*renew_lease)(struct nfs_client *, const struct cred *);
     257                 :            : };
     258                 :            : 
     259                 :            : struct nfs4_mig_recovery_ops {
     260                 :            :         int (*get_locations)(struct inode *, struct nfs4_fs_locations *,
     261                 :            :                 struct page *, const struct cred *);
     262                 :            :         int (*fsid_present)(struct inode *, const struct cred *);
     263                 :            : };
     264                 :            : 
     265                 :            : extern const struct dentry_operations nfs4_dentry_operations;
     266                 :            : 
     267                 :            : /* dir.c */
     268                 :            : int nfs_atomic_open(struct inode *, struct dentry *, struct file *,
     269                 :            :                     unsigned, umode_t);
     270                 :            : 
     271                 :            : /* super.c */
     272                 :            : extern struct file_system_type nfs4_fs_type;
     273                 :            : 
     274                 :            : /* nfs4namespace.c */
     275                 :            : struct rpc_clnt *nfs4_negotiate_security(struct rpc_clnt *, struct inode *,
     276                 :            :                                          const struct qstr *);
     277                 :            : struct vfsmount *nfs4_submount(struct nfs_server *, struct dentry *,
     278                 :            :                                struct nfs_fh *, struct nfs_fattr *);
     279                 :            : int nfs4_replace_transport(struct nfs_server *server,
     280                 :            :                                 const struct nfs4_fs_locations *locations);
     281                 :            : 
     282                 :            : /* nfs4proc.c */
     283                 :            : extern int nfs4_handle_exception(struct nfs_server *, int, struct nfs4_exception *);
     284                 :            : extern int nfs4_async_handle_error(struct rpc_task *task,
     285                 :            :                                    struct nfs_server *server,
     286                 :            :                                    struct nfs4_state *state, long *timeout);
     287                 :            : extern int nfs4_call_sync(struct rpc_clnt *, struct nfs_server *,
     288                 :            :                           struct rpc_message *, struct nfs4_sequence_args *,
     289                 :            :                           struct nfs4_sequence_res *, int);
     290                 :            : extern void nfs4_init_sequence(struct nfs4_sequence_args *, struct nfs4_sequence_res *, int, int);
     291                 :            : extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, const struct cred *, struct nfs4_setclientid_res *);
     292                 :            : extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct nfs4_setclientid_res *arg, const struct cred *);
     293                 :            : extern int nfs4_proc_get_rootfh(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *, bool);
     294                 :            : extern int nfs4_proc_bind_conn_to_session(struct nfs_client *, const struct cred *cred);
     295                 :            : extern int nfs4_proc_exchange_id(struct nfs_client *clp, const struct cred *cred);
     296                 :            : extern int nfs4_destroy_clientid(struct nfs_client *clp);
     297                 :            : extern int nfs4_init_clientid(struct nfs_client *, const struct cred *);
     298                 :            : extern int nfs41_init_clientid(struct nfs_client *, const struct cred *);
     299                 :            : extern int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait);
     300                 :            : extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);
     301                 :            : extern int nfs4_proc_fs_locations(struct rpc_clnt *, struct inode *, const struct qstr *,
     302                 :            :                                   struct nfs4_fs_locations *, struct page *);
     303                 :            : extern int nfs4_proc_get_locations(struct inode *, struct nfs4_fs_locations *,
     304                 :            :                 struct page *page, const struct cred *);
     305                 :            : extern int nfs4_proc_fsid_present(struct inode *, const struct cred *);
     306                 :            : extern struct rpc_clnt *nfs4_proc_lookup_mountpoint(struct inode *, const struct qstr *,
     307                 :            :                             struct nfs_fh *, struct nfs_fattr *);
     308                 :            : extern int nfs4_proc_secinfo(struct inode *, const struct qstr *, struct nfs4_secinfo_flavors *);
     309                 :            : extern const struct xattr_handler *nfs4_xattr_handlers[];
     310                 :            : extern int nfs4_set_rw_stateid(nfs4_stateid *stateid,
     311                 :            :                 const struct nfs_open_context *ctx,
     312                 :            :                 const struct nfs_lock_context *l_ctx,
     313                 :            :                 fmode_t fmode);
     314                 :            : 
     315                 :            : extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
     316                 :            :                 struct nfs_fsinfo *fsinfo);
     317                 :            : #if defined(CONFIG_NFS_V4_1)
     318                 :            : extern int nfs41_sequence_done(struct rpc_task *, struct nfs4_sequence_res *);
     319                 :            : extern int nfs4_proc_create_session(struct nfs_client *, const struct cred *);
     320                 :            : extern int nfs4_proc_destroy_session(struct nfs4_session *, const struct cred *);
     321                 :            : extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data,
     322                 :            :                                   bool sync);
     323                 :            : extern int nfs4_detect_session_trunking(struct nfs_client *clp,
     324                 :            :                 struct nfs41_exchange_id_res *res, struct rpc_xprt *xprt);
     325                 :            : 
     326                 :            : static inline bool
     327                 :            : is_ds_only_client(struct nfs_client *clp)
     328                 :            : {
     329                 :          0 :         return (clp->cl_exchange_flags & EXCHGID4_FLAG_MASK_PNFS) ==
     330                 :            :                 EXCHGID4_FLAG_USE_PNFS_DS;
     331                 :            : }
     332                 :            : 
     333                 :            : static inline bool
     334                 :            : is_ds_client(struct nfs_client *clp)
     335                 :            : {
     336                 :          0 :         return clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_DS;
     337                 :            : }
     338                 :            : 
     339                 :            : static inline bool
     340                 :          0 : _nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
     341                 :            :                     struct rpc_clnt **clntp, struct rpc_message *msg)
     342                 :            : {
     343                 :            :         rpc_authflavor_t flavor;
     344                 :            : 
     345         [ #  # ]:          0 :         if (sp4_mode == NFS_SP4_MACH_CRED_CLEANUP ||
     346                 :          0 :             sp4_mode == NFS_SP4_MACH_CRED_PNFS_CLEANUP) {
     347                 :            :                 /* Using machine creds for cleanup operations
     348                 :            :                  * is only relevent if the client credentials
     349                 :            :                  * might expire. So don't bother for
     350                 :            :                  * RPC_AUTH_UNIX.  If file was only exported to
     351                 :            :                  * sec=sys, the PUTFH would fail anyway.
     352                 :            :                  */
     353         [ #  # ]:          0 :                 if ((*clntp)->cl_auth->au_flavor == RPC_AUTH_UNIX)
     354                 :            :                         return false;
     355                 :            :         }
     356         [ #  # ]:          0 :         if (test_bit(sp4_mode, &clp->cl_sp4_flags)) {
     357                 :          0 :                 msg->rpc_cred = rpc_machine_cred();
     358                 :            : 
     359                 :          0 :                 flavor = clp->cl_rpcclient->cl_auth->au_flavor;
     360   [ #  #  #  # ]:          0 :                 WARN_ON_ONCE(flavor != RPC_AUTH_GSS_KRB5I &&
     361                 :            :                              flavor != RPC_AUTH_GSS_KRB5P);
     362                 :          0 :                 *clntp = clp->cl_rpcclient;
     363                 :            : 
     364                 :          0 :                 return true;
     365                 :            :         }
     366                 :            :         return false;
     367                 :            : }
     368                 :            : 
     369                 :            : /*
     370                 :            :  * Function responsible for determining if an rpc_message should use the
     371                 :            :  * machine cred under SP4_MACH_CRED and if so switching the credential and
     372                 :            :  * authflavor (using the nfs_client's rpc_clnt which will be krb5i/p).
     373                 :            :  * Should be called before rpc_call_sync/rpc_call_async.
     374                 :            :  */
     375                 :            : static inline void
     376                 :            : nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
     377                 :            :                    struct rpc_clnt **clntp, struct rpc_message *msg)
     378                 :            : {
     379                 :          0 :         _nfs4_state_protect(clp, sp4_mode, clntp, msg);
     380                 :            : }
     381                 :            : 
     382                 :            : /*
     383                 :            :  * Special wrapper to nfs4_state_protect for write.
     384                 :            :  * If WRITE can use machine cred but COMMIT cannot, make sure all writes
     385                 :            :  * that use machine cred use NFS_FILE_SYNC.
     386                 :            :  */
     387                 :            : static inline void
     388                 :          0 : nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
     389                 :            :                          struct rpc_message *msg, struct nfs_pgio_header *hdr)
     390                 :            : {
     391   [ #  #  #  # ]:          0 :         if (_nfs4_state_protect(clp, NFS_SP4_MACH_CRED_WRITE, clntp, msg) &&
     392                 :            :             !test_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags))
     393                 :          0 :                 hdr->args.stable = NFS_FILE_SYNC;
     394                 :          0 : }
     395                 :            : #else /* CONFIG_NFS_v4_1 */
     396                 :            : static inline bool
     397                 :            : is_ds_only_client(struct nfs_client *clp)
     398                 :            : {
     399                 :            :         return false;
     400                 :            : }
     401                 :            : 
     402                 :            : static inline bool
     403                 :            : is_ds_client(struct nfs_client *clp)
     404                 :            : {
     405                 :            :         return false;
     406                 :            : }
     407                 :            : 
     408                 :            : static inline void
     409                 :            : nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_flags,
     410                 :            :                    struct rpc_clnt **clntp, struct rpc_message *msg)
     411                 :            : {
     412                 :            : }
     413                 :            : 
     414                 :            : static inline void
     415                 :            : nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
     416                 :            :                          struct rpc_message *msg, struct nfs_pgio_header *hdr)
     417                 :            : {
     418                 :            : }
     419                 :            : #endif /* CONFIG_NFS_V4_1 */
     420                 :            : 
     421                 :            : extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
     422                 :            : 
     423                 :            : extern const u32 nfs4_fattr_bitmap[3];
     424                 :            : extern const u32 nfs4_statfs_bitmap[3];
     425                 :            : extern const u32 nfs4_pathconf_bitmap[3];
     426                 :            : extern const u32 nfs4_fsinfo_bitmap[3];
     427                 :            : extern const u32 nfs4_fs_locations_bitmap[3];
     428                 :            : 
     429                 :            : void nfs40_shutdown_client(struct nfs_client *);
     430                 :            : void nfs41_shutdown_client(struct nfs_client *);
     431                 :            : int nfs40_init_client(struct nfs_client *);
     432                 :            : int nfs41_init_client(struct nfs_client *);
     433                 :            : void nfs4_free_client(struct nfs_client *);
     434                 :            : 
     435                 :            : struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *);
     436                 :            : 
     437                 :            : /* nfs4renewd.c */
     438                 :            : extern void nfs4_schedule_state_renewal(struct nfs_client *);
     439                 :            : extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
     440                 :            : extern void nfs4_kill_renewd(struct nfs_client *);
     441                 :            : extern void nfs4_renew_state(struct work_struct *);
     442                 :            : extern void nfs4_set_lease_period(struct nfs_client *clp, unsigned long lease);
     443                 :            : 
     444                 :            : 
     445                 :            : /* nfs4state.c */
     446                 :            : const struct cred *nfs4_get_clid_cred(struct nfs_client *clp);
     447                 :            : const struct cred *nfs4_get_machine_cred(struct nfs_client *clp);
     448                 :            : const struct cred *nfs4_get_renew_cred(struct nfs_client *clp);
     449                 :            : int nfs4_discover_server_trunking(struct nfs_client *clp,
     450                 :            :                         struct nfs_client **);
     451                 :            : int nfs40_discover_server_trunking(struct nfs_client *clp,
     452                 :            :                         struct nfs_client **, const struct cred *);
     453                 :            : #if defined(CONFIG_NFS_V4_1)
     454                 :            : int nfs41_discover_server_trunking(struct nfs_client *clp,
     455                 :            :                         struct nfs_client **, const struct cred *);
     456                 :            : extern void nfs4_schedule_session_recovery(struct nfs4_session *, int);
     457                 :            : extern void nfs41_notify_server(struct nfs_client *);
     458                 :            : #else
     459                 :            : static inline void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
     460                 :            : {
     461                 :            : }
     462                 :            : #endif /* CONFIG_NFS_V4_1 */
     463                 :            : 
     464                 :            : extern struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *, const struct cred *, gfp_t);
     465                 :            : extern void nfs4_put_state_owner(struct nfs4_state_owner *);
     466                 :            : extern void nfs4_purge_state_owners(struct nfs_server *, struct list_head *);
     467                 :            : extern void nfs4_free_state_owners(struct list_head *head);
     468                 :            : extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
     469                 :            : extern void nfs4_put_open_state(struct nfs4_state *);
     470                 :            : extern void nfs4_close_state(struct nfs4_state *, fmode_t);
     471                 :            : extern void nfs4_close_sync(struct nfs4_state *, fmode_t);
     472                 :            : extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
     473                 :            : extern void nfs_inode_find_state_and_recover(struct inode *inode,
     474                 :            :                 const nfs4_stateid *stateid);
     475                 :            : extern int nfs4_state_mark_reclaim_nograce(struct nfs_client *, struct nfs4_state *);
     476                 :            : extern void nfs4_schedule_lease_recovery(struct nfs_client *);
     477                 :            : extern int nfs4_wait_clnt_recover(struct nfs_client *clp);
     478                 :            : extern int nfs4_client_recover_expired_lease(struct nfs_client *clp);
     479                 :            : extern void nfs4_schedule_state_manager(struct nfs_client *);
     480                 :            : extern void nfs4_schedule_path_down_recovery(struct nfs_client *clp);
     481                 :            : extern int nfs4_schedule_stateid_recovery(const struct nfs_server *, struct nfs4_state *);
     482                 :            : extern int nfs4_schedule_migration_recovery(const struct nfs_server *);
     483                 :            : extern void nfs4_schedule_lease_moved_recovery(struct nfs_client *);
     484                 :            : extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags, bool);
     485                 :            : extern void nfs41_handle_server_scope(struct nfs_client *,
     486                 :            :                                       struct nfs41_server_scope **);
     487                 :            : extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
     488                 :            : extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
     489                 :            : extern int nfs4_select_rw_stateid(struct nfs4_state *, fmode_t,
     490                 :            :                 const struct nfs_lock_context *, nfs4_stateid *,
     491                 :            :                 const struct cred **);
     492                 :            : extern bool nfs4_copy_open_stateid(nfs4_stateid *dst,
     493                 :            :                 struct nfs4_state *state);
     494                 :            : 
     495                 :            : extern struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask);
     496                 :            : extern int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task);
     497                 :            : extern void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid);
     498                 :            : extern void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid);
     499                 :            : extern void nfs_release_seqid(struct nfs_seqid *seqid);
     500                 :            : extern void nfs_free_seqid(struct nfs_seqid *seqid);
     501                 :            : extern int nfs4_setup_sequence(struct nfs_client *client,
     502                 :            :                                 struct nfs4_sequence_args *args,
     503                 :            :                                 struct nfs4_sequence_res *res,
     504                 :            :                                 struct rpc_task *task);
     505                 :            : extern int nfs4_sequence_done(struct rpc_task *task,
     506                 :            :                               struct nfs4_sequence_res *res);
     507                 :            : 
     508                 :            : extern void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp);
     509                 :            : extern int nfs4_proc_commit(struct file *dst, __u64 offset, __u32 count, struct nfs_commitres *res);
     510                 :            : extern const nfs4_stateid zero_stateid;
     511                 :            : extern const nfs4_stateid invalid_stateid;
     512                 :            : 
     513                 :            : /* nfs4super.c */
     514                 :            : struct nfs_mount_info;
     515                 :            : extern struct nfs_subversion nfs_v4;
     516                 :            : struct dentry *nfs4_try_mount(int, const char *, struct nfs_mount_info *, struct nfs_subversion *);
     517                 :            : extern bool nfs4_disable_idmapping;
     518                 :            : extern unsigned short max_session_slots;
     519                 :            : extern unsigned short max_session_cb_slots;
     520                 :            : extern unsigned short send_implementation_id;
     521                 :            : extern bool recover_lost_locks;
     522                 :            : 
     523                 :            : #define NFS4_CLIENT_ID_UNIQ_LEN         (64)
     524                 :            : extern char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN];
     525                 :            : 
     526                 :            : /* nfs4sysctl.c */
     527                 :            : #ifdef CONFIG_SYSCTL
     528                 :            : int nfs4_register_sysctl(void);
     529                 :            : void nfs4_unregister_sysctl(void);
     530                 :            : #else
     531                 :            : static inline int nfs4_register_sysctl(void)
     532                 :            : {
     533                 :            :         return 0;
     534                 :            : }
     535                 :            : 
     536                 :            : static inline void nfs4_unregister_sysctl(void)
     537                 :            : {
     538                 :            : }
     539                 :            : #endif
     540                 :            : 
     541                 :            : /* nfs4xdr.c */
     542                 :            : extern const struct rpc_procinfo nfs4_procedures[];
     543                 :            : 
     544                 :            : struct nfs4_mount_data;
     545                 :            : 
     546                 :            : /* callback_xdr.c */
     547                 :            : extern const struct svc_version nfs4_callback_version1;
     548                 :            : extern const struct svc_version nfs4_callback_version4;
     549                 :            : 
     550                 :            : static inline void nfs4_stateid_copy(nfs4_stateid *dst, const nfs4_stateid *src)
     551                 :            : {
     552                 :          0 :         memcpy(dst->data, src->data, sizeof(dst->data));
     553                 :          0 :         dst->type = src->type;
     554                 :            : }
     555                 :            : 
     556                 :            : static inline bool nfs4_stateid_match(const nfs4_stateid *dst, const nfs4_stateid *src)
     557                 :            : {
     558   [ #  #  #  #  :          0 :         if (dst->type != src->type)
          #  #  #  #  #  
                #  #  # ]
     559                 :            :                 return false;
     560                 :          0 :         return memcmp(dst->data, src->data, sizeof(dst->data)) == 0;
     561                 :            : }
     562                 :            : 
     563                 :            : static inline bool nfs4_stateid_match_other(const nfs4_stateid *dst, const nfs4_stateid *src)
     564                 :            : {
     565                 :          0 :         return memcmp(dst->other, src->other, NFS4_STATEID_OTHER_SIZE) == 0;
     566                 :            : }
     567                 :            : 
     568                 :            : static inline bool nfs4_stateid_is_newer(const nfs4_stateid *s1, const nfs4_stateid *s2)
     569                 :            : {
     570                 :          0 :         return (s32)(be32_to_cpu(s1->seqid) - be32_to_cpu(s2->seqid)) > 0;
     571                 :            : }
     572                 :            : 
     573                 :            : static inline void nfs4_stateid_seqid_inc(nfs4_stateid *s1)
     574                 :            : {
     575                 :            :         u32 seqid = be32_to_cpu(s1->seqid);
     576                 :            : 
     577         [ #  # ]:          0 :         if (++seqid == 0)
     578                 :          0 :                 ++seqid;
     579                 :          0 :         s1->seqid = cpu_to_be32(seqid);
     580                 :            : }
     581                 :            : 
     582                 :            : static inline bool nfs4_valid_open_stateid(const struct nfs4_state *state)
     583                 :            : {
     584                 :            :         return test_bit(NFS_STATE_RECOVERY_FAILED, &state->flags) == 0;
     585                 :            : }
     586                 :            : 
     587                 :          0 : static inline bool nfs4_state_match_open_stateid_other(const struct nfs4_state *state,
     588                 :            :                 const nfs4_stateid *stateid)
     589                 :            : {
     590   [ #  #  #  # ]:          0 :         return test_bit(NFS_OPEN_STATE, &state->flags) &&
     591                 :            :                 nfs4_stateid_match_other(&state->open_stateid, stateid);
     592                 :            : }
     593                 :            : 
     594                 :            : #else
     595                 :            : 
     596                 :            : #define nfs4_close_state(a, b) do { } while (0)
     597                 :            : #define nfs4_close_sync(a, b) do { } while (0)
     598                 :            : #define nfs4_state_protect(a, b, c, d) do { } while (0)
     599                 :            : #define nfs4_state_protect_write(a, b, c, d) do { } while (0)
     600                 :            : 
     601                 :            : #endif /* CONFIG_NFS_V4 */
     602                 :            : #endif /* __LINUX_FS_NFS_NFS4_FS.H */

Generated by: LCOV version 1.14