1 /* SPDX-License-Identifier: GPL-2.0 */
3 * linux/fs/nfs/nfs4_fs.h
5 * Copyright (C) 2005 Trond Myklebust
7 * NFSv4-specific filesystem definitions and declarations
10 #ifndef __LINUX_FS_NFS_NFS4_FS_H
11 #define __LINUX_FS_NFS_NFS4_FS_H
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
18 #define NFS4_MAX_MINOR_VERSION 0
21 #if IS_ENABLED(CONFIG_NFS_V4)
23 #define NFS4_MAX_LOOP_ON_RECOVER (10)
25 #include <linux/seqlock.h>
29 enum nfs4_client_state
{
30 NFS4CLNT_MANAGER_RUNNING
= 0,
32 NFS4CLNT_LEASE_EXPIRED
,
33 NFS4CLNT_RECLAIM_REBOOT
,
34 NFS4CLNT_RECLAIM_NOGRACE
,
36 NFS4CLNT_SESSION_RESET
,
37 NFS4CLNT_LEASE_CONFIRM
,
38 NFS4CLNT_SERVER_SCOPE_MISMATCH
,
40 NFS4CLNT_BIND_CONN_TO_SESSION
,
43 NFS4CLNT_DELEGATION_EXPIRED
,
45 NFS4CLNT_RECALL_RUNNING
,
46 NFS4CLNT_RECALL_ANY_LAYOUT_READ
,
47 NFS4CLNT_RECALL_ANY_LAYOUT_RW
,
50 #define NFS4_RENEW_TIMEOUT 0x01
51 #define NFS4_RENEW_DELEGATION_CB 0x02
53 struct nfs_seqid_counter
;
54 struct nfs4_minor_version_ops
{
58 int (*init_client
)(struct nfs_client
*);
59 void (*shutdown_client
)(struct nfs_client
*);
60 bool (*match_stateid
)(const nfs4_stateid
*,
61 const nfs4_stateid
*);
62 int (*find_root_sec
)(struct nfs_server
*, struct nfs_fh
*,
64 void (*free_lock_state
)(struct nfs_server
*,
65 struct nfs4_lock_state
*);
66 int (*test_and_free_expired
)(struct nfs_server
*,
67 nfs4_stateid
*, const struct cred
*);
69 (*alloc_seqid
)(struct nfs_seqid_counter
*, gfp_t
);
70 void (*session_trunk
)(struct rpc_clnt
*clnt
,
71 struct rpc_xprt
*xprt
, void *data
);
72 const struct rpc_call_ops
*call_sync_ops
;
73 const struct nfs4_state_recovery_ops
*reboot_recovery_ops
;
74 const struct nfs4_state_recovery_ops
*nograce_recovery_ops
;
75 const struct nfs4_state_maintenance_ops
*state_renewal_ops
;
76 const struct nfs4_mig_recovery_ops
*mig_recovery_ops
;
79 #define NFS_SEQID_CONFIRMED 1
80 struct nfs_seqid_counter
{
85 spinlock_t lock
; /* Protects the list */
86 struct list_head list
; /* Defines sequence of RPC calls */
87 struct rpc_wait_queue wait
; /* RPC call delay queue */
91 struct nfs_seqid_counter
*sequence
;
92 struct list_head list
;
93 struct rpc_task
*task
;
96 static inline void nfs_confirm_seqid(struct nfs_seqid_counter
*seqid
, int status
)
98 if (seqid_mutating_err(-status
))
99 seqid
->flags
|= NFS_SEQID_CONFIRMED
;
103 * NFS4 state_owners and lock_owners are simply labels for ordered
104 * sequences of RPC calls. Their sole purpose is to provide once-only
105 * semantics by allowing the server to identify replayed requests.
107 struct nfs4_state_owner
{
108 struct nfs_server
*so_server
;
109 struct list_head so_lru
;
110 unsigned long so_expires
;
111 struct rb_node so_server_node
;
113 const struct cred
*so_cred
; /* Associated cred */
117 unsigned long so_flags
;
118 struct list_head so_states
;
119 struct nfs_seqid_counter so_seqid
;
120 seqcount_spinlock_t so_reclaim_seqcount
;
121 struct mutex so_delegreturn_mutex
;
125 NFS_OWNER_RECLAIM_REBOOT
,
126 NFS_OWNER_RECLAIM_NOGRACE
129 #define NFS_LOCK_NEW 0
130 #define NFS_LOCK_RECLAIM 1
131 #define NFS_LOCK_EXPIRED 2
134 * struct nfs4_state maintains the client-side state for a given
135 * (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
138 * In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
139 * we need to know how many files are open for reading or writing on a
140 * given inode. This information too is stored here.
142 * LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
145 struct nfs4_lock_state
{
146 struct list_head ls_locks
; /* Other lock stateids */
147 struct nfs4_state
* ls_state
; /* Pointer to open state */
148 #define NFS_LOCK_INITIALIZED 0
149 #define NFS_LOCK_LOST 1
150 unsigned long ls_flags
;
151 struct nfs_seqid_counter ls_seqid
;
152 nfs4_stateid ls_stateid
;
157 /* bits for nfs4_state->flags */
160 NFS_DELEGATED_STATE
, /* Current stateid is delegation */
161 NFS_OPEN_STATE
, /* OPEN stateid is set */
162 NFS_O_RDONLY_STATE
, /* OPEN stateid has read-only state */
163 NFS_O_WRONLY_STATE
, /* OPEN stateid has write-only state */
164 NFS_O_RDWR_STATE
, /* OPEN stateid has read/write state */
165 NFS_STATE_RECLAIM_REBOOT
, /* OPEN stateid server rebooted */
166 NFS_STATE_RECLAIM_NOGRACE
, /* OPEN stateid needs to recover state */
167 NFS_STATE_POSIX_LOCKS
, /* Posix locks are supported */
168 NFS_STATE_RECOVERY_FAILED
, /* OPEN stateid state recovery failed */
169 NFS_STATE_MAY_NOTIFY_LOCK
, /* server may CB_NOTIFY_LOCK */
170 NFS_STATE_CHANGE_WAIT
, /* A state changing operation is outstanding */
171 NFS_CLNT_DST_SSC_COPY_STATE
, /* dst server open state on client*/
172 NFS_CLNT_SRC_SSC_COPY_STATE
, /* src server open state on client*/
173 NFS_SRV_SSC_COPY_STATE
, /* ssc state on the dst server */
177 struct list_head open_states
; /* List of states for the same state_owner */
178 struct list_head inode_states
; /* List of states for the same inode */
179 struct list_head lock_states
; /* List of subservient lock stateids */
181 struct nfs4_state_owner
*owner
; /* Pointer to the open owner */
182 struct inode
*inode
; /* Pointer to the inode */
184 unsigned long flags
; /* Do we hold any locks? */
185 spinlock_t state_lock
; /* Protects the lock_states list */
187 seqlock_t seqlock
; /* Protects the stateid/open_stateid */
188 nfs4_stateid stateid
; /* Current stateid: may be delegation */
189 nfs4_stateid open_stateid
; /* OPEN stateid */
191 /* The following 3 fields are protected by owner->so_lock */
192 unsigned int n_rdonly
; /* Number of read-only references */
193 unsigned int n_wronly
; /* Number of write-only references */
194 unsigned int n_rdwr
; /* Number of read/write references */
195 fmode_t state
; /* State on the server (R,W, or RW) */
198 wait_queue_head_t waitq
;
199 struct rcu_head rcu_head
;
203 struct nfs4_exception
{
204 struct nfs4_state
*state
;
206 nfs4_stateid
*stateid
;
208 unsigned char delay
: 1,
214 struct nfs4_state_recovery_ops
{
217 int (*recover_open
)(struct nfs4_state_owner
*, struct nfs4_state
*);
218 int (*recover_lock
)(struct nfs4_state
*, struct file_lock
*);
219 int (*establish_clid
)(struct nfs_client
*, const struct cred
*);
220 int (*reclaim_complete
)(struct nfs_client
*, const struct cred
*);
221 int (*detect_trunking
)(struct nfs_client
*, struct nfs_client
**,
222 const struct cred
*);
225 struct nfs4_opendata
{
227 struct nfs_openargs o_arg
;
228 struct nfs_openres o_res
;
229 struct nfs_open_confirmargs c_arg
;
230 struct nfs_open_confirmres c_res
;
231 struct nfs4_string owner_name
;
232 struct nfs4_string group_name
;
233 struct nfs4_label
*a_label
;
234 struct nfs_fattr f_attr
;
235 struct nfs4_label
*f_label
;
237 struct dentry
*dentry
;
238 struct nfs4_state_owner
*owner
;
239 struct nfs4_state
*state
;
241 struct nfs4_layoutget
*lgp
;
242 unsigned long timestamp
;
250 struct nfs4_add_xprt_data
{
251 struct nfs_client
*clp
;
252 const struct cred
*cred
;
255 struct nfs4_state_maintenance_ops
{
256 int (*sched_state_renewal
)(struct nfs_client
*, const struct cred
*, unsigned);
257 const struct cred
* (*get_state_renewal_cred
)(struct nfs_client
*);
258 int (*renew_lease
)(struct nfs_client
*, const struct cred
*);
261 struct nfs4_mig_recovery_ops
{
262 int (*get_locations
)(struct inode
*, struct nfs4_fs_locations
*,
263 struct page
*, const struct cred
*);
264 int (*fsid_present
)(struct inode
*, const struct cred
*);
267 extern const struct dentry_operations nfs4_dentry_operations
;
270 int nfs_atomic_open(struct inode
*, struct dentry
*, struct file
*,
274 extern struct file_system_type nfs4_fs_type
;
276 /* nfs4namespace.c */
277 struct rpc_clnt
*nfs4_negotiate_security(struct rpc_clnt
*, struct inode
*,
278 const struct qstr
*);
279 int nfs4_submount(struct fs_context
*, struct nfs_server
*);
280 int nfs4_replace_transport(struct nfs_server
*server
,
281 const struct nfs4_fs_locations
*locations
);
284 extern int nfs4_handle_exception(struct nfs_server
*, int, struct nfs4_exception
*);
285 extern int nfs4_async_handle_error(struct rpc_task
*task
,
286 struct nfs_server
*server
,
287 struct nfs4_state
*state
, long *timeout
);
288 extern int nfs4_call_sync(struct rpc_clnt
*, struct nfs_server
*,
289 struct rpc_message
*, struct nfs4_sequence_args
*,
290 struct nfs4_sequence_res
*, int);
291 extern void nfs4_init_sequence(struct nfs4_sequence_args
*, struct nfs4_sequence_res
*, int, int);
292 extern int nfs4_proc_setclientid(struct nfs_client
*, u32
, unsigned short, const struct cred
*, struct nfs4_setclientid_res
*);
293 extern int nfs4_proc_setclientid_confirm(struct nfs_client
*, struct nfs4_setclientid_res
*arg
, const struct cred
*);
294 extern int nfs4_proc_get_rootfh(struct nfs_server
*, struct nfs_fh
*, struct nfs_fsinfo
*, bool);
295 extern int nfs4_proc_bind_conn_to_session(struct nfs_client
*, const struct cred
*cred
);
296 extern int nfs4_proc_exchange_id(struct nfs_client
*clp
, const struct cred
*cred
);
297 extern int nfs4_destroy_clientid(struct nfs_client
*clp
);
298 extern int nfs4_init_clientid(struct nfs_client
*, const struct cred
*);
299 extern int nfs41_init_clientid(struct nfs_client
*, const struct cred
*);
300 extern int nfs4_do_close(struct nfs4_state
*state
, gfp_t gfp_mask
, int wait
);
301 extern int nfs4_server_capabilities(struct nfs_server
*server
, struct nfs_fh
*fhandle
);
302 extern int nfs4_proc_fs_locations(struct rpc_clnt
*, struct inode
*, const struct qstr
*,
303 struct nfs4_fs_locations
*, struct page
*);
304 extern int nfs4_proc_get_locations(struct inode
*, struct nfs4_fs_locations
*,
305 struct page
*page
, const struct cred
*);
306 extern int nfs4_proc_fsid_present(struct inode
*, const struct cred
*);
307 extern struct rpc_clnt
*nfs4_proc_lookup_mountpoint(struct inode
*,
311 extern int nfs4_proc_secinfo(struct inode
*, const struct qstr
*, struct nfs4_secinfo_flavors
*);
312 extern const struct xattr_handler
*nfs4_xattr_handlers
[];
313 extern int nfs4_set_rw_stateid(nfs4_stateid
*stateid
,
314 const struct nfs_open_context
*ctx
,
315 const struct nfs_lock_context
*l_ctx
,
317 extern int nfs4_proc_getattr(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
318 struct nfs_fattr
*fattr
, struct nfs4_label
*label
,
319 struct inode
*inode
);
320 extern int update_open_stateid(struct nfs4_state
*state
,
321 const nfs4_stateid
*open_stateid
,
322 const nfs4_stateid
*deleg_stateid
,
325 extern int nfs4_proc_get_lease_time(struct nfs_client
*clp
,
326 struct nfs_fsinfo
*fsinfo
);
327 extern void nfs4_update_changeattr(struct inode
*dir
,
328 struct nfs4_change_info
*cinfo
,
329 unsigned long timestamp
,
330 unsigned long cache_validity
);
331 extern int nfs4_buf_to_pages_noslab(const void *buf
, size_t buflen
,
332 struct page
**pages
);
334 #if defined(CONFIG_NFS_V4_1)
335 extern int nfs41_sequence_done(struct rpc_task
*, struct nfs4_sequence_res
*);
336 extern int nfs4_proc_create_session(struct nfs_client
*, const struct cred
*);
337 extern int nfs4_proc_destroy_session(struct nfs4_session
*, const struct cred
*);
338 extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data
*data
,
340 extern int nfs4_detect_session_trunking(struct nfs_client
*clp
,
341 struct nfs41_exchange_id_res
*res
, struct rpc_xprt
*xprt
);
344 is_ds_only_client(struct nfs_client
*clp
)
346 return (clp
->cl_exchange_flags
& EXCHGID4_FLAG_MASK_PNFS
) ==
347 EXCHGID4_FLAG_USE_PNFS_DS
;
351 is_ds_client(struct nfs_client
*clp
)
353 return clp
->cl_exchange_flags
& EXCHGID4_FLAG_USE_PNFS_DS
;
357 _nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_mode
,
358 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
360 rpc_authflavor_t flavor
;
362 if (sp4_mode
== NFS_SP4_MACH_CRED_CLEANUP
||
363 sp4_mode
== NFS_SP4_MACH_CRED_PNFS_CLEANUP
) {
364 /* Using machine creds for cleanup operations
365 * is only relevent if the client credentials
366 * might expire. So don't bother for
367 * RPC_AUTH_UNIX. If file was only exported to
368 * sec=sys, the PUTFH would fail anyway.
370 if ((*clntp
)->cl_auth
->au_flavor
== RPC_AUTH_UNIX
)
373 if (test_bit(sp4_mode
, &clp
->cl_sp4_flags
)) {
374 msg
->rpc_cred
= rpc_machine_cred();
376 flavor
= clp
->cl_rpcclient
->cl_auth
->au_flavor
;
377 WARN_ON_ONCE(flavor
!= RPC_AUTH_GSS_KRB5I
&&
378 flavor
!= RPC_AUTH_GSS_KRB5P
);
379 *clntp
= clp
->cl_rpcclient
;
387 * Function responsible for determining if an rpc_message should use the
388 * machine cred under SP4_MACH_CRED and if so switching the credential and
389 * authflavor (using the nfs_client's rpc_clnt which will be krb5i/p).
390 * Should be called before rpc_call_sync/rpc_call_async.
393 nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_mode
,
394 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
396 _nfs4_state_protect(clp
, sp4_mode
, clntp
, msg
);
400 * Special wrapper to nfs4_state_protect for write.
401 * If WRITE can use machine cred but COMMIT cannot, make sure all writes
402 * that use machine cred use NFS_FILE_SYNC.
405 nfs4_state_protect_write(struct nfs_client
*clp
, struct rpc_clnt
**clntp
,
406 struct rpc_message
*msg
, struct nfs_pgio_header
*hdr
)
408 if (_nfs4_state_protect(clp
, NFS_SP4_MACH_CRED_WRITE
, clntp
, msg
) &&
409 !test_bit(NFS_SP4_MACH_CRED_COMMIT
, &clp
->cl_sp4_flags
))
410 hdr
->args
.stable
= NFS_FILE_SYNC
;
412 #else /* CONFIG_NFS_v4_1 */
414 is_ds_only_client(struct nfs_client
*clp
)
420 is_ds_client(struct nfs_client
*clp
)
426 nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_flags
,
427 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
432 nfs4_state_protect_write(struct nfs_client
*clp
, struct rpc_clnt
**clntp
,
433 struct rpc_message
*msg
, struct nfs_pgio_header
*hdr
)
436 #endif /* CONFIG_NFS_V4_1 */
438 extern const struct nfs4_minor_version_ops
*nfs_v4_minor_ops
[];
440 extern const u32 nfs4_fattr_bitmap
[3];
441 extern const u32 nfs4_statfs_bitmap
[3];
442 extern const u32 nfs4_pathconf_bitmap
[3];
443 extern const u32 nfs4_fsinfo_bitmap
[3];
444 extern const u32 nfs4_fs_locations_bitmap
[3];
446 void nfs40_shutdown_client(struct nfs_client
*);
447 void nfs41_shutdown_client(struct nfs_client
*);
448 int nfs40_init_client(struct nfs_client
*);
449 int nfs41_init_client(struct nfs_client
*);
450 void nfs4_free_client(struct nfs_client
*);
452 struct nfs_client
*nfs4_alloc_client(const struct nfs_client_initdata
*);
455 extern void nfs4_schedule_state_renewal(struct nfs_client
*);
456 extern void nfs4_renewd_prepare_shutdown(struct nfs_server
*);
457 extern void nfs4_kill_renewd(struct nfs_client
*);
458 extern void nfs4_renew_state(struct work_struct
*);
459 extern void nfs4_set_lease_period(struct nfs_client
*clp
, unsigned long lease
);
463 extern const nfs4_stateid current_stateid
;
465 const struct cred
*nfs4_get_clid_cred(struct nfs_client
*clp
);
466 const struct cred
*nfs4_get_machine_cred(struct nfs_client
*clp
);
467 const struct cred
*nfs4_get_renew_cred(struct nfs_client
*clp
);
468 int nfs4_discover_server_trunking(struct nfs_client
*clp
,
469 struct nfs_client
**);
470 int nfs40_discover_server_trunking(struct nfs_client
*clp
,
471 struct nfs_client
**, const struct cred
*);
472 #if defined(CONFIG_NFS_V4_1)
473 int nfs41_discover_server_trunking(struct nfs_client
*clp
,
474 struct nfs_client
**, const struct cred
*);
475 extern void nfs4_schedule_session_recovery(struct nfs4_session
*, int);
476 extern void nfs41_notify_server(struct nfs_client
*);
477 bool nfs4_check_serverowner_major_id(struct nfs41_server_owner
*o1
,
478 struct nfs41_server_owner
*o2
);
480 static inline void nfs4_schedule_session_recovery(struct nfs4_session
*session
, int err
)
483 #endif /* CONFIG_NFS_V4_1 */
485 extern struct nfs4_state_owner
*nfs4_get_state_owner(struct nfs_server
*, const struct cred
*, gfp_t
);
486 extern void nfs4_put_state_owner(struct nfs4_state_owner
*);
487 extern void nfs4_purge_state_owners(struct nfs_server
*, struct list_head
*);
488 extern void nfs4_free_state_owners(struct list_head
*head
);
489 extern struct nfs4_state
* nfs4_get_open_state(struct inode
*, struct nfs4_state_owner
*);
490 extern void nfs4_put_open_state(struct nfs4_state
*);
491 extern void nfs4_close_state(struct nfs4_state
*, fmode_t
);
492 extern void nfs4_close_sync(struct nfs4_state
*, fmode_t
);
493 extern void nfs4_state_set_mode_locked(struct nfs4_state
*, fmode_t
);
494 extern void nfs_inode_find_state_and_recover(struct inode
*inode
,
495 const nfs4_stateid
*stateid
);
496 extern int nfs4_state_mark_reclaim_nograce(struct nfs_client
*, struct nfs4_state
*);
497 extern void nfs4_schedule_lease_recovery(struct nfs_client
*);
498 extern int nfs4_wait_clnt_recover(struct nfs_client
*clp
);
499 extern int nfs4_client_recover_expired_lease(struct nfs_client
*clp
);
500 extern void nfs4_schedule_state_manager(struct nfs_client
*);
501 extern void nfs4_schedule_path_down_recovery(struct nfs_client
*clp
);
502 extern int nfs4_schedule_stateid_recovery(const struct nfs_server
*, struct nfs4_state
*);
503 extern int nfs4_schedule_migration_recovery(const struct nfs_server
*);
504 extern void nfs4_schedule_lease_moved_recovery(struct nfs_client
*);
505 extern void nfs41_handle_sequence_flag_errors(struct nfs_client
*clp
, u32 flags
, bool);
506 extern void nfs41_handle_server_scope(struct nfs_client
*,
507 struct nfs41_server_scope
**);
508 extern void nfs4_put_lock_state(struct nfs4_lock_state
*lsp
);
509 extern int nfs4_set_lock_state(struct nfs4_state
*state
, struct file_lock
*fl
);
510 extern int nfs4_select_rw_stateid(struct nfs4_state
*, fmode_t
,
511 const struct nfs_lock_context
*, nfs4_stateid
*,
512 const struct cred
**);
513 extern bool nfs4_copy_open_stateid(nfs4_stateid
*dst
,
514 struct nfs4_state
*state
);
516 extern struct nfs_seqid
*nfs_alloc_seqid(struct nfs_seqid_counter
*counter
, gfp_t gfp_mask
);
517 extern int nfs_wait_on_sequence(struct nfs_seqid
*seqid
, struct rpc_task
*task
);
518 extern void nfs_increment_open_seqid(int status
, struct nfs_seqid
*seqid
);
519 extern void nfs_increment_lock_seqid(int status
, struct nfs_seqid
*seqid
);
520 extern void nfs_release_seqid(struct nfs_seqid
*seqid
);
521 extern void nfs_free_seqid(struct nfs_seqid
*seqid
);
522 extern int nfs4_setup_sequence(struct nfs_client
*client
,
523 struct nfs4_sequence_args
*args
,
524 struct nfs4_sequence_res
*res
,
525 struct rpc_task
*task
);
526 extern int nfs4_sequence_done(struct rpc_task
*task
,
527 struct nfs4_sequence_res
*res
);
529 extern void nfs4_free_lock_state(struct nfs_server
*server
, struct nfs4_lock_state
*lsp
);
530 extern int nfs4_proc_commit(struct file
*dst
, __u64 offset
, __u32 count
, struct nfs_commitres
*res
);
531 extern const nfs4_stateid zero_stateid
;
532 extern const nfs4_stateid invalid_stateid
;
535 struct nfs_mount_info
;
536 extern struct nfs_subversion nfs_v4
;
537 extern bool nfs4_disable_idmapping
;
538 extern unsigned short max_session_slots
;
539 extern unsigned short max_session_cb_slots
;
540 extern unsigned short send_implementation_id
;
541 extern bool recover_lost_locks
;
543 #define NFS4_CLIENT_ID_UNIQ_LEN (64)
544 extern char nfs4_client_id_uniquifier
[NFS4_CLIENT_ID_UNIQ_LEN
];
546 extern int nfs4_try_get_tree(struct fs_context
*);
547 extern int nfs4_get_referral_tree(struct fs_context
*);
551 int nfs4_register_sysctl(void);
552 void nfs4_unregister_sysctl(void);
554 static inline int nfs4_register_sysctl(void)
559 static inline void nfs4_unregister_sysctl(void)
565 extern const struct rpc_procinfo nfs4_procedures
[];
567 #ifdef CONFIG_NFS_V4_2
568 extern const u32 nfs42_maxsetxattr_overhead
;
569 extern const u32 nfs42_maxgetxattr_overhead
;
570 extern const u32 nfs42_maxlistxattrs_overhead
;
573 struct nfs4_mount_data
;
576 extern const struct svc_version nfs4_callback_version1
;
577 extern const struct svc_version nfs4_callback_version4
;
579 static inline void nfs4_stateid_copy(nfs4_stateid
*dst
, const nfs4_stateid
*src
)
581 memcpy(dst
->data
, src
->data
, sizeof(dst
->data
));
582 dst
->type
= src
->type
;
585 static inline bool nfs4_stateid_match(const nfs4_stateid
*dst
, const nfs4_stateid
*src
)
587 if (dst
->type
!= src
->type
)
589 return memcmp(dst
->data
, src
->data
, sizeof(dst
->data
)) == 0;
592 static inline bool nfs4_stateid_match_other(const nfs4_stateid
*dst
, const nfs4_stateid
*src
)
594 return memcmp(dst
->other
, src
->other
, NFS4_STATEID_OTHER_SIZE
) == 0;
597 static inline bool nfs4_stateid_is_newer(const nfs4_stateid
*s1
, const nfs4_stateid
*s2
)
599 return (s32
)(be32_to_cpu(s1
->seqid
) - be32_to_cpu(s2
->seqid
)) > 0;
602 static inline bool nfs4_stateid_is_next(const nfs4_stateid
*s1
, const nfs4_stateid
*s2
)
604 u32 seq1
= be32_to_cpu(s1
->seqid
);
605 u32 seq2
= be32_to_cpu(s2
->seqid
);
607 return seq2
== seq1
+ 1U || (seq2
== 1U && seq1
== 0xffffffffU
);
610 static inline bool nfs4_stateid_match_or_older(const nfs4_stateid
*dst
, const nfs4_stateid
*src
)
612 return nfs4_stateid_match_other(dst
, src
) &&
613 !(src
->seqid
&& nfs4_stateid_is_newer(dst
, src
));
616 static inline void nfs4_stateid_seqid_inc(nfs4_stateid
*s1
)
618 u32 seqid
= be32_to_cpu(s1
->seqid
);
622 s1
->seqid
= cpu_to_be32(seqid
);
625 static inline bool nfs4_valid_open_stateid(const struct nfs4_state
*state
)
627 return test_bit(NFS_STATE_RECOVERY_FAILED
, &state
->flags
) == 0;
630 static inline bool nfs4_state_match_open_stateid_other(const struct nfs4_state
*state
,
631 const nfs4_stateid
*stateid
)
633 return test_bit(NFS_OPEN_STATE
, &state
->flags
) &&
634 nfs4_stateid_match_other(&state
->open_stateid
, stateid
);
638 #ifdef CONFIG_NFS_V4_2
639 extern int __init
nfs4_xattr_cache_init(void);
640 extern void nfs4_xattr_cache_exit(void);
641 extern void nfs4_xattr_cache_add(struct inode
*inode
, const char *name
,
642 const char *buf
, struct page
**pages
,
644 extern void nfs4_xattr_cache_remove(struct inode
*inode
, const char *name
);
645 extern ssize_t
nfs4_xattr_cache_get(struct inode
*inode
, const char *name
,
646 char *buf
, ssize_t buflen
);
647 extern void nfs4_xattr_cache_set_list(struct inode
*inode
, const char *buf
,
649 extern ssize_t
nfs4_xattr_cache_list(struct inode
*inode
, char *buf
,
651 extern void nfs4_xattr_cache_zap(struct inode
*inode
);
653 static inline void nfs4_xattr_cache_zap(struct inode
*inode
)
656 #endif /* CONFIG_NFS_V4_2 */
658 #else /* CONFIG_NFS_V4 */
660 #define nfs4_close_state(a, b) do { } while (0)
661 #define nfs4_close_sync(a, b) do { } while (0)
662 #define nfs4_state_protect(a, b, c, d) do { } while (0)
663 #define nfs4_state_protect_write(a, b, c, d) do { } while (0)
666 #endif /* CONFIG_NFS_V4 */
667 #endif /* __LINUX_FS_NFS_NFS4_FS.H */