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
nfs_confirm_seqid(struct nfs_seqid_counter * seqid,int status)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 #ifdef CONFIG_NFS_V4_2
167 NFS_CLNT_DST_SSC_COPY_STATE, /* dst server open state on client*/
168 #endif /* CONFIG_NFS_V4_2 */
169 };
170
171 struct nfs4_state {
172 struct list_head open_states; /* List of states for the same state_owner */
173 struct list_head inode_states; /* List of states for the same inode */
174 struct list_head lock_states; /* List of subservient lock stateids */
175
176 struct nfs4_state_owner *owner; /* Pointer to the open owner */
177 struct inode *inode; /* Pointer to the inode */
178
179 unsigned long flags; /* Do we hold any locks? */
180 spinlock_t state_lock; /* Protects the lock_states list */
181
182 seqlock_t seqlock; /* Protects the stateid/open_stateid */
183 nfs4_stateid stateid; /* Current stateid: may be delegation */
184 nfs4_stateid open_stateid; /* OPEN stateid */
185
186 /* The following 3 fields are protected by owner->so_lock */
187 unsigned int n_rdonly; /* Number of read-only references */
188 unsigned int n_wronly; /* Number of write-only references */
189 unsigned int n_rdwr; /* Number of read/write references */
190 fmode_t state; /* State on the server (R,W, or RW) */
191 atomic_t count;
192
193 wait_queue_head_t waitq;
194 };
195
196
197 struct nfs4_exception {
198 struct nfs4_state *state;
199 struct inode *inode;
200 nfs4_stateid *stateid;
201 long timeout;
202 unsigned char delay : 1,
203 recovering : 1,
204 retry : 1;
205 };
206
207 struct nfs4_state_recovery_ops {
208 int owner_flag_bit;
209 int state_flag_bit;
210 int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *);
211 int (*recover_lock)(struct nfs4_state *, struct file_lock *);
212 int (*establish_clid)(struct nfs_client *, struct rpc_cred *);
213 int (*reclaim_complete)(struct nfs_client *, struct rpc_cred *);
214 int (*detect_trunking)(struct nfs_client *, struct nfs_client **,
215 struct rpc_cred *);
216 };
217
218 struct nfs4_opendata {
219 struct kref kref;
220 struct nfs_openargs o_arg;
221 struct nfs_openres o_res;
222 struct nfs_open_confirmargs c_arg;
223 struct nfs_open_confirmres c_res;
224 struct nfs4_string owner_name;
225 struct nfs4_string group_name;
226 struct nfs4_label *a_label;
227 struct nfs_fattr f_attr;
228 struct nfs4_label *f_label;
229 struct dentry *dir;
230 struct dentry *dentry;
231 struct nfs4_state_owner *owner;
232 struct nfs4_state *state;
233 struct iattr attrs;
234 struct nfs4_layoutget *lgp;
235 unsigned long timestamp;
236 bool rpc_done;
237 bool file_created;
238 bool is_recover;
239 bool cancelled;
240 int rpc_status;
241 };
242
243 struct nfs4_add_xprt_data {
244 struct nfs_client *clp;
245 struct rpc_cred *cred;
246 };
247
248 struct nfs4_state_maintenance_ops {
249 int (*sched_state_renewal)(struct nfs_client *, struct rpc_cred *, unsigned);
250 struct rpc_cred * (*get_state_renewal_cred_locked)(struct nfs_client *);
251 int (*renew_lease)(struct nfs_client *, struct rpc_cred *);
252 };
253
254 struct nfs4_mig_recovery_ops {
255 int (*get_locations)(struct inode *, struct nfs4_fs_locations *,
256 struct page *, struct rpc_cred *);
257 int (*fsid_present)(struct inode *, struct rpc_cred *);
258 };
259
260 extern const struct dentry_operations nfs4_dentry_operations;
261
262 /* dir.c */
263 int nfs_atomic_open(struct inode *, struct dentry *, struct file *,
264 unsigned, umode_t);
265
266 /* super.c */
267 extern struct file_system_type nfs4_fs_type;
268
269 /* nfs4namespace.c */
270 struct rpc_clnt *nfs4_negotiate_security(struct rpc_clnt *, struct inode *,
271 const struct qstr *);
272 struct vfsmount *nfs4_submount(struct nfs_server *, struct dentry *,
273 struct nfs_fh *, struct nfs_fattr *);
274 int nfs4_replace_transport(struct nfs_server *server,
275 const struct nfs4_fs_locations *locations);
276
277 /* nfs4proc.c */
278 extern int nfs4_handle_exception(struct nfs_server *, int, struct nfs4_exception *);
279 extern int nfs4_async_handle_error(struct rpc_task *task,
280 struct nfs_server *server,
281 struct nfs4_state *state, long *timeout);
282 extern int nfs4_call_sync(struct rpc_clnt *, struct nfs_server *,
283 struct rpc_message *, struct nfs4_sequence_args *,
284 struct nfs4_sequence_res *, int);
285 extern void nfs4_init_sequence(struct nfs4_sequence_args *, struct nfs4_sequence_res *, int, int);
286 extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, struct rpc_cred *, struct nfs4_setclientid_res *);
287 extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct nfs4_setclientid_res *arg, struct rpc_cred *);
288 extern int nfs4_proc_get_rootfh(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *, bool);
289 extern int nfs4_proc_bind_conn_to_session(struct nfs_client *, struct rpc_cred *cred);
290 extern int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred);
291 extern int nfs4_destroy_clientid(struct nfs_client *clp);
292 extern int nfs4_init_clientid(struct nfs_client *, struct rpc_cred *);
293 extern int nfs41_init_clientid(struct nfs_client *, struct rpc_cred *);
294 extern int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait);
295 extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);
296 extern int nfs4_proc_fs_locations(struct rpc_clnt *, struct inode *, const struct qstr *,
297 struct nfs4_fs_locations *, struct page *);
298 extern int nfs4_proc_get_locations(struct inode *, struct nfs4_fs_locations *,
299 struct page *page, struct rpc_cred *);
300 extern int nfs4_proc_fsid_present(struct inode *, struct rpc_cred *);
301 extern struct rpc_clnt *nfs4_proc_lookup_mountpoint(struct inode *, const struct qstr *,
302 struct nfs_fh *, struct nfs_fattr *);
303 extern int nfs4_proc_secinfo(struct inode *, const struct qstr *, struct nfs4_secinfo_flavors *);
304 extern const struct xattr_handler *nfs4_xattr_handlers[];
305 extern int nfs4_set_rw_stateid(nfs4_stateid *stateid,
306 const struct nfs_open_context *ctx,
307 const struct nfs_lock_context *l_ctx,
308 fmode_t fmode);
309
310 #if defined(CONFIG_NFS_V4_1)
311 extern int nfs41_sequence_done(struct rpc_task *, struct nfs4_sequence_res *);
312 extern int nfs4_proc_create_session(struct nfs_client *, struct rpc_cred *);
313 extern int nfs4_proc_destroy_session(struct nfs4_session *, struct rpc_cred *);
314 extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
315 struct nfs_fsinfo *fsinfo);
316 extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data,
317 bool sync);
318 extern int nfs4_detect_session_trunking(struct nfs_client *clp,
319 struct nfs41_exchange_id_res *res, struct rpc_xprt *xprt);
320
321 static inline bool
is_ds_only_client(struct nfs_client * clp)322 is_ds_only_client(struct nfs_client *clp)
323 {
324 return (clp->cl_exchange_flags & EXCHGID4_FLAG_MASK_PNFS) ==
325 EXCHGID4_FLAG_USE_PNFS_DS;
326 }
327
328 static inline bool
is_ds_client(struct nfs_client * clp)329 is_ds_client(struct nfs_client *clp)
330 {
331 return clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_DS;
332 }
333
334 static inline bool
_nfs4_state_protect(struct nfs_client * clp,unsigned long sp4_mode,struct rpc_clnt ** clntp,struct rpc_message * msg)335 _nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
336 struct rpc_clnt **clntp, struct rpc_message *msg)
337 {
338 struct rpc_cred *newcred = NULL;
339 rpc_authflavor_t flavor;
340
341 if (sp4_mode == NFS_SP4_MACH_CRED_CLEANUP ||
342 sp4_mode == NFS_SP4_MACH_CRED_PNFS_CLEANUP) {
343 /* Using machine creds for cleanup operations
344 * is only relevent if the client credentials
345 * might expire. So don't bother for
346 * RPC_AUTH_UNIX. If file was only exported to
347 * sec=sys, the PUTFH would fail anyway.
348 */
349 if ((*clntp)->cl_auth->au_flavor == RPC_AUTH_UNIX)
350 return false;
351 }
352 if (test_bit(sp4_mode, &clp->cl_sp4_flags)) {
353 spin_lock(&clp->cl_lock);
354 if (clp->cl_machine_cred != NULL)
355 /* don't call get_rpccred on the machine cred -
356 * a reference will be held for life of clp */
357 newcred = clp->cl_machine_cred;
358 spin_unlock(&clp->cl_lock);
359 msg->rpc_cred = newcred;
360
361 flavor = clp->cl_rpcclient->cl_auth->au_flavor;
362 WARN_ON_ONCE(flavor != RPC_AUTH_GSS_KRB5I &&
363 flavor != RPC_AUTH_GSS_KRB5P);
364 *clntp = clp->cl_rpcclient;
365
366 return true;
367 }
368 return false;
369 }
370
371 /*
372 * Function responsible for determining if an rpc_message should use the
373 * machine cred under SP4_MACH_CRED and if so switching the credential and
374 * authflavor (using the nfs_client's rpc_clnt which will be krb5i/p).
375 * Should be called before rpc_call_sync/rpc_call_async.
376 */
377 static inline void
nfs4_state_protect(struct nfs_client * clp,unsigned long sp4_mode,struct rpc_clnt ** clntp,struct rpc_message * msg)378 nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
379 struct rpc_clnt **clntp, struct rpc_message *msg)
380 {
381 _nfs4_state_protect(clp, sp4_mode, clntp, msg);
382 }
383
384 /*
385 * Special wrapper to nfs4_state_protect for write.
386 * If WRITE can use machine cred but COMMIT cannot, make sure all writes
387 * that use machine cred use NFS_FILE_SYNC.
388 */
389 static inline void
nfs4_state_protect_write(struct nfs_client * clp,struct rpc_clnt ** clntp,struct rpc_message * msg,struct nfs_pgio_header * hdr)390 nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
391 struct rpc_message *msg, struct nfs_pgio_header *hdr)
392 {
393 if (_nfs4_state_protect(clp, NFS_SP4_MACH_CRED_WRITE, clntp, msg) &&
394 !test_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags))
395 hdr->args.stable = NFS_FILE_SYNC;
396 }
397 #else /* CONFIG_NFS_v4_1 */
398 static inline bool
is_ds_only_client(struct nfs_client * clp)399 is_ds_only_client(struct nfs_client *clp)
400 {
401 return false;
402 }
403
404 static inline bool
is_ds_client(struct nfs_client * clp)405 is_ds_client(struct nfs_client *clp)
406 {
407 return false;
408 }
409
410 static inline void
nfs4_state_protect(struct nfs_client * clp,unsigned long sp4_flags,struct rpc_clnt ** clntp,struct rpc_message * msg)411 nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_flags,
412 struct rpc_clnt **clntp, struct rpc_message *msg)
413 {
414 }
415
416 static inline void
nfs4_state_protect_write(struct nfs_client * clp,struct rpc_clnt ** clntp,struct rpc_message * msg,struct nfs_pgio_header * hdr)417 nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
418 struct rpc_message *msg, struct nfs_pgio_header *hdr)
419 {
420 }
421 #endif /* CONFIG_NFS_V4_1 */
422
423 extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
424
425 extern const u32 nfs4_fattr_bitmap[3];
426 extern const u32 nfs4_statfs_bitmap[3];
427 extern const u32 nfs4_pathconf_bitmap[3];
428 extern const u32 nfs4_fsinfo_bitmap[3];
429 extern const u32 nfs4_fs_locations_bitmap[3];
430
431 void nfs40_shutdown_client(struct nfs_client *);
432 void nfs41_shutdown_client(struct nfs_client *);
433 int nfs40_init_client(struct nfs_client *);
434 int nfs41_init_client(struct nfs_client *);
435 void nfs4_free_client(struct nfs_client *);
436
437 struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *);
438
439 /* nfs4renewd.c */
440 extern void nfs4_schedule_state_renewal(struct nfs_client *);
441 extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
442 extern void nfs4_kill_renewd(struct nfs_client *);
443 extern void nfs4_renew_state(struct work_struct *);
444 extern void nfs4_set_lease_period(struct nfs_client *clp,
445 unsigned long lease,
446 unsigned long lastrenewed);
447
448
449 /* nfs4state.c */
450 struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp);
451 struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp);
452 struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp);
453 int nfs4_discover_server_trunking(struct nfs_client *clp,
454 struct nfs_client **);
455 int nfs40_discover_server_trunking(struct nfs_client *clp,
456 struct nfs_client **, struct rpc_cred *);
457 #if defined(CONFIG_NFS_V4_1)
458 int nfs41_discover_server_trunking(struct nfs_client *clp,
459 struct nfs_client **, struct rpc_cred *);
460 extern void nfs4_schedule_session_recovery(struct nfs4_session *, int);
461 extern void nfs41_notify_server(struct nfs_client *);
462 #else
nfs4_schedule_session_recovery(struct nfs4_session * session,int err)463 static inline void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
464 {
465 }
466 #endif /* CONFIG_NFS_V4_1 */
467
468 extern struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *, gfp_t);
469 extern void nfs4_put_state_owner(struct nfs4_state_owner *);
470 extern void nfs4_purge_state_owners(struct nfs_server *);
471 extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
472 extern void nfs4_put_open_state(struct nfs4_state *);
473 extern void nfs4_close_state(struct nfs4_state *, fmode_t);
474 extern void nfs4_close_sync(struct nfs4_state *, fmode_t);
475 extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
476 extern void nfs_inode_find_state_and_recover(struct inode *inode,
477 const nfs4_stateid *stateid);
478 extern int nfs4_state_mark_reclaim_nograce(struct nfs_client *, struct nfs4_state *);
479 extern void nfs4_schedule_lease_recovery(struct nfs_client *);
480 extern int nfs4_wait_clnt_recover(struct nfs_client *clp);
481 extern int nfs4_client_recover_expired_lease(struct nfs_client *clp);
482 extern void nfs4_schedule_state_manager(struct nfs_client *);
483 extern void nfs4_schedule_path_down_recovery(struct nfs_client *clp);
484 extern int nfs4_schedule_stateid_recovery(const struct nfs_server *, struct nfs4_state *);
485 extern int nfs4_schedule_migration_recovery(const struct nfs_server *);
486 extern void nfs4_schedule_lease_moved_recovery(struct nfs_client *);
487 extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags, bool);
488 extern void nfs41_handle_server_scope(struct nfs_client *,
489 struct nfs41_server_scope **);
490 extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
491 extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
492 extern int nfs4_select_rw_stateid(struct nfs4_state *, fmode_t,
493 const struct nfs_lock_context *, nfs4_stateid *,
494 struct rpc_cred **);
495 extern bool nfs4_refresh_open_stateid(nfs4_stateid *dst,
496 struct nfs4_state *state);
497 extern bool nfs4_copy_open_stateid(nfs4_stateid *dst,
498 struct nfs4_state *state);
499
500 extern struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask);
501 extern int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task);
502 extern void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid);
503 extern void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid);
504 extern void nfs_release_seqid(struct nfs_seqid *seqid);
505 extern void nfs_free_seqid(struct nfs_seqid *seqid);
506 extern int nfs4_setup_sequence(struct nfs_client *client,
507 struct nfs4_sequence_args *args,
508 struct nfs4_sequence_res *res,
509 struct rpc_task *task);
510 extern int nfs4_sequence_done(struct rpc_task *task,
511 struct nfs4_sequence_res *res);
512
513 extern void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp);
514 extern int nfs4_proc_commit(struct file *dst, __u64 offset, __u32 count, struct nfs_commitres *res);
515 extern const nfs4_stateid zero_stateid;
516 extern const nfs4_stateid invalid_stateid;
517
518 /* nfs4super.c */
519 struct nfs_mount_info;
520 extern struct nfs_subversion nfs_v4;
521 struct dentry *nfs4_try_mount(int, const char *, struct nfs_mount_info *, struct nfs_subversion *);
522 extern bool nfs4_disable_idmapping;
523 extern unsigned short max_session_slots;
524 extern unsigned short max_session_cb_slots;
525 extern unsigned short send_implementation_id;
526 extern bool recover_lost_locks;
527
528 #define NFS4_CLIENT_ID_UNIQ_LEN (64)
529 extern char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN];
530
531 /* nfs4sysctl.c */
532 #ifdef CONFIG_SYSCTL
533 int nfs4_register_sysctl(void);
534 void nfs4_unregister_sysctl(void);
535 #else
nfs4_register_sysctl(void)536 static inline int nfs4_register_sysctl(void)
537 {
538 return 0;
539 }
540
nfs4_unregister_sysctl(void)541 static inline void nfs4_unregister_sysctl(void)
542 {
543 }
544 #endif
545
546 /* nfs4xdr.c */
547 extern const struct rpc_procinfo nfs4_procedures[];
548
549 struct nfs4_mount_data;
550
551 /* callback_xdr.c */
552 extern const struct svc_version nfs4_callback_version1;
553 extern const struct svc_version nfs4_callback_version4;
554
nfs4_stateid_copy(nfs4_stateid * dst,const nfs4_stateid * src)555 static inline void nfs4_stateid_copy(nfs4_stateid *dst, const nfs4_stateid *src)
556 {
557 memcpy(dst->data, src->data, sizeof(dst->data));
558 dst->type = src->type;
559 }
560
nfs4_stateid_match(const nfs4_stateid * dst,const nfs4_stateid * src)561 static inline bool nfs4_stateid_match(const nfs4_stateid *dst, const nfs4_stateid *src)
562 {
563 if (dst->type != src->type)
564 return false;
565 return memcmp(dst->data, src->data, sizeof(dst->data)) == 0;
566 }
567
nfs4_stateid_match_other(const nfs4_stateid * dst,const nfs4_stateid * src)568 static inline bool nfs4_stateid_match_other(const nfs4_stateid *dst, const nfs4_stateid *src)
569 {
570 return memcmp(dst->other, src->other, NFS4_STATEID_OTHER_SIZE) == 0;
571 }
572
nfs4_stateid_is_newer(const nfs4_stateid * s1,const nfs4_stateid * s2)573 static inline bool nfs4_stateid_is_newer(const nfs4_stateid *s1, const nfs4_stateid *s2)
574 {
575 return (s32)(be32_to_cpu(s1->seqid) - be32_to_cpu(s2->seqid)) > 0;
576 }
577
nfs4_valid_open_stateid(const struct nfs4_state * state)578 static inline bool nfs4_valid_open_stateid(const struct nfs4_state *state)
579 {
580 return test_bit(NFS_STATE_RECOVERY_FAILED, &state->flags) == 0;
581 }
582
nfs4_state_match_open_stateid_other(const struct nfs4_state * state,const nfs4_stateid * stateid)583 static inline bool nfs4_state_match_open_stateid_other(const struct nfs4_state *state,
584 const nfs4_stateid *stateid)
585 {
586 return test_bit(NFS_OPEN_STATE, &state->flags) &&
587 nfs4_stateid_match_other(&state->open_stateid, stateid);
588 }
589
590 #else
591
592 #define nfs4_close_state(a, b) do { } while (0)
593 #define nfs4_close_sync(a, b) do { } while (0)
594 #define nfs4_state_protect(a, b, c, d) do { } while (0)
595 #define nfs4_state_protect_write(a, b, c, d) do { } while (0)
596
597 #endif /* CONFIG_NFS_V4 */
598 #endif /* __LINUX_FS_NFS_NFS4_FS.H */
599
