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