2 * linux/fs/nfs/nfs4_fs.h
4 * Copyright (C) 2005 Trond Myklebust
6 * NFSv4-specific filesystem definitions and declarations
9 #ifndef __LINUX_FS_NFS_NFS4_FS_H
10 #define __LINUX_FS_NFS_NFS4_FS_H
12 #if defined(CONFIG_NFS_V4_2)
13 #define NFS4_MAX_MINOR_VERSION 2
14 #elif defined(CONFIG_NFS_V4_1)
15 #define NFS4_MAX_MINOR_VERSION 1
17 #define NFS4_MAX_MINOR_VERSION 0
20 #if IS_ENABLED(CONFIG_NFS_V4)
22 #define NFS4_MAX_LOOP_ON_RECOVER (10)
24 #include <linux/seqlock.h>
28 enum nfs4_client_state
{
29 NFS4CLNT_MANAGER_RUNNING
= 0,
31 NFS4CLNT_LEASE_EXPIRED
,
32 NFS4CLNT_RECLAIM_REBOOT
,
33 NFS4CLNT_RECLAIM_NOGRACE
,
35 NFS4CLNT_SESSION_RESET
,
36 NFS4CLNT_LEASE_CONFIRM
,
37 NFS4CLNT_SERVER_SCOPE_MISMATCH
,
39 NFS4CLNT_BIND_CONN_TO_SESSION
,
42 NFS4CLNT_DELEGATION_EXPIRED
,
45 #define NFS4_RENEW_TIMEOUT 0x01
46 #define NFS4_RENEW_DELEGATION_CB 0x02
48 struct nfs_seqid_counter
;
49 struct nfs4_minor_version_ops
{
53 int (*init_client
)(struct nfs_client
*);
54 void (*shutdown_client
)(struct nfs_client
*);
55 bool (*match_stateid
)(const nfs4_stateid
*,
56 const nfs4_stateid
*);
57 int (*find_root_sec
)(struct nfs_server
*, struct nfs_fh
*,
59 void (*free_lock_state
)(struct nfs_server
*,
60 struct nfs4_lock_state
*);
61 int (*test_and_free_expired
)(struct nfs_server
*,
62 nfs4_stateid
*, struct rpc_cred
*);
64 (*alloc_seqid
)(struct nfs_seqid_counter
*, gfp_t
);
65 int (*session_trunk
)(struct rpc_clnt
*, struct rpc_xprt
*, void *);
66 const struct rpc_call_ops
*call_sync_ops
;
67 const struct nfs4_state_recovery_ops
*reboot_recovery_ops
;
68 const struct nfs4_state_recovery_ops
*nograce_recovery_ops
;
69 const struct nfs4_state_maintenance_ops
*state_renewal_ops
;
70 const struct nfs4_mig_recovery_ops
*mig_recovery_ops
;
73 #define NFS_SEQID_CONFIRMED 1
74 struct nfs_seqid_counter
{
79 spinlock_t lock
; /* Protects the list */
80 struct list_head list
; /* Defines sequence of RPC calls */
81 struct rpc_wait_queue wait
; /* RPC call delay queue */
85 struct nfs_seqid_counter
*sequence
;
86 struct list_head list
;
87 struct rpc_task
*task
;
90 static inline void nfs_confirm_seqid(struct nfs_seqid_counter
*seqid
, int status
)
92 if (seqid_mutating_err(-status
))
93 seqid
->flags
|= NFS_SEQID_CONFIRMED
;
97 * NFS4 state_owners and lock_owners are simply labels for ordered
98 * sequences of RPC calls. Their sole purpose is to provide once-only
99 * semantics by allowing the server to identify replayed requests.
101 struct nfs4_state_owner
{
102 struct nfs_server
*so_server
;
103 struct list_head so_lru
;
104 unsigned long so_expires
;
105 struct rb_node so_server_node
;
107 struct rpc_cred
*so_cred
; /* Associated cred */
111 unsigned long so_flags
;
112 struct list_head so_states
;
113 struct nfs_seqid_counter so_seqid
;
114 seqcount_t so_reclaim_seqcount
;
115 struct mutex so_delegreturn_mutex
;
119 NFS_OWNER_RECLAIM_REBOOT
,
120 NFS_OWNER_RECLAIM_NOGRACE
123 #define NFS_LOCK_NEW 0
124 #define NFS_LOCK_RECLAIM 1
125 #define NFS_LOCK_EXPIRED 2
128 * struct nfs4_state maintains the client-side state for a given
129 * (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
132 * In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
133 * we need to know how many files are open for reading or writing on a
134 * given inode. This information too is stored here.
136 * LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
139 struct nfs4_lock_state
{
140 struct list_head ls_locks
; /* Other lock stateids */
141 struct nfs4_state
* ls_state
; /* Pointer to open state */
142 #define NFS_LOCK_INITIALIZED 0
143 #define NFS_LOCK_LOST 1
144 unsigned long ls_flags
;
145 struct nfs_seqid_counter ls_seqid
;
146 nfs4_stateid ls_stateid
;
151 /* bits for nfs4_state->flags */
154 NFS_DELEGATED_STATE
, /* Current stateid is delegation */
155 NFS_OPEN_STATE
, /* OPEN stateid is set */
156 NFS_O_RDONLY_STATE
, /* OPEN stateid has read-only state */
157 NFS_O_WRONLY_STATE
, /* OPEN stateid has write-only state */
158 NFS_O_RDWR_STATE
, /* OPEN stateid has read/write state */
159 NFS_STATE_RECLAIM_REBOOT
, /* OPEN stateid server rebooted */
160 NFS_STATE_RECLAIM_NOGRACE
, /* OPEN stateid needs to recover state */
161 NFS_STATE_POSIX_LOCKS
, /* Posix locks are supported */
162 NFS_STATE_RECOVERY_FAILED
, /* OPEN stateid state recovery failed */
163 NFS_STATE_MAY_NOTIFY_LOCK
, /* server may CB_NOTIFY_LOCK */
167 struct list_head open_states
; /* List of states for the same state_owner */
168 struct list_head inode_states
; /* List of states for the same inode */
169 struct list_head lock_states
; /* List of subservient lock stateids */
171 struct nfs4_state_owner
*owner
; /* Pointer to the open owner */
172 struct inode
*inode
; /* Pointer to the inode */
174 unsigned long flags
; /* Do we hold any locks? */
175 spinlock_t state_lock
; /* Protects the lock_states list */
177 seqlock_t seqlock
; /* Protects the stateid/open_stateid */
178 nfs4_stateid stateid
; /* Current stateid: may be delegation */
179 nfs4_stateid open_stateid
; /* OPEN stateid */
181 /* The following 3 fields are protected by owner->so_lock */
182 unsigned int n_rdonly
; /* Number of read-only references */
183 unsigned int n_wronly
; /* Number of write-only references */
184 unsigned int n_rdwr
; /* Number of read/write references */
185 fmode_t state
; /* State on the server (R,W, or RW) */
190 struct nfs4_exception
{
191 struct nfs4_state
*state
;
193 nfs4_stateid
*stateid
;
195 unsigned char delay
: 1,
200 struct nfs4_state_recovery_ops
{
203 int (*recover_open
)(struct nfs4_state_owner
*, struct nfs4_state
*);
204 int (*recover_lock
)(struct nfs4_state
*, struct file_lock
*);
205 int (*establish_clid
)(struct nfs_client
*, struct rpc_cred
*);
206 int (*reclaim_complete
)(struct nfs_client
*, struct rpc_cred
*);
207 int (*detect_trunking
)(struct nfs_client
*, struct nfs_client
**,
211 struct nfs4_add_xprt_data
{
212 struct nfs_client
*clp
;
213 struct rpc_cred
*cred
;
216 struct nfs4_state_maintenance_ops
{
217 int (*sched_state_renewal
)(struct nfs_client
*, struct rpc_cred
*, unsigned);
218 struct rpc_cred
* (*get_state_renewal_cred_locked
)(struct nfs_client
*);
219 int (*renew_lease
)(struct nfs_client
*, struct rpc_cred
*);
222 struct nfs4_mig_recovery_ops
{
223 int (*get_locations
)(struct inode
*, struct nfs4_fs_locations
*,
224 struct page
*, struct rpc_cred
*);
225 int (*fsid_present
)(struct inode
*, struct rpc_cred
*);
228 extern const struct dentry_operations nfs4_dentry_operations
;
231 int nfs_atomic_open(struct inode
*, struct dentry
*, struct file
*,
232 unsigned, umode_t
, int *);
235 extern struct file_system_type nfs4_fs_type
;
237 /* nfs4namespace.c */
238 struct rpc_clnt
*nfs4_negotiate_security(struct rpc_clnt
*, struct inode
*,
239 const struct qstr
*);
240 struct vfsmount
*nfs4_submount(struct nfs_server
*, struct dentry
*,
241 struct nfs_fh
*, struct nfs_fattr
*);
242 int nfs4_replace_transport(struct nfs_server
*server
,
243 const struct nfs4_fs_locations
*locations
);
246 extern int nfs4_handle_exception(struct nfs_server
*, int, struct nfs4_exception
*);
247 extern int nfs4_call_sync(struct rpc_clnt
*, struct nfs_server
*,
248 struct rpc_message
*, struct nfs4_sequence_args
*,
249 struct nfs4_sequence_res
*, int);
250 extern void nfs4_init_sequence(struct nfs4_sequence_args
*, struct nfs4_sequence_res
*, int);
251 extern int nfs4_proc_setclientid(struct nfs_client
*, u32
, unsigned short, struct rpc_cred
*, struct nfs4_setclientid_res
*);
252 extern int nfs4_proc_setclientid_confirm(struct nfs_client
*, struct nfs4_setclientid_res
*arg
, struct rpc_cred
*);
253 extern int nfs4_proc_get_rootfh(struct nfs_server
*, struct nfs_fh
*, struct nfs_fsinfo
*, bool);
254 extern int nfs4_proc_bind_conn_to_session(struct nfs_client
*, struct rpc_cred
*cred
);
255 extern int nfs4_proc_exchange_id(struct nfs_client
*clp
, struct rpc_cred
*cred
);
256 extern int nfs4_destroy_clientid(struct nfs_client
*clp
);
257 extern int nfs4_init_clientid(struct nfs_client
*, struct rpc_cred
*);
258 extern int nfs41_init_clientid(struct nfs_client
*, struct rpc_cred
*);
259 extern int nfs4_do_close(struct nfs4_state
*state
, gfp_t gfp_mask
, int wait
);
260 extern int nfs4_server_capabilities(struct nfs_server
*server
, struct nfs_fh
*fhandle
);
261 extern int nfs4_proc_fs_locations(struct rpc_clnt
*, struct inode
*, const struct qstr
*,
262 struct nfs4_fs_locations
*, struct page
*);
263 extern int nfs4_proc_get_locations(struct inode
*, struct nfs4_fs_locations
*,
264 struct page
*page
, struct rpc_cred
*);
265 extern int nfs4_proc_fsid_present(struct inode
*, struct rpc_cred
*);
266 extern struct rpc_clnt
*nfs4_proc_lookup_mountpoint(struct inode
*, const struct qstr
*,
267 struct nfs_fh
*, struct nfs_fattr
*);
268 extern int nfs4_proc_secinfo(struct inode
*, const struct qstr
*, struct nfs4_secinfo_flavors
*);
269 extern const struct xattr_handler
*nfs4_xattr_handlers
[];
270 extern int nfs4_set_rw_stateid(nfs4_stateid
*stateid
,
271 const struct nfs_open_context
*ctx
,
272 const struct nfs_lock_context
*l_ctx
,
275 #if defined(CONFIG_NFS_V4_1)
276 static inline struct nfs4_session
*nfs4_get_session(const struct nfs_server
*server
)
278 return server
->nfs_client
->cl_session
;
281 extern int nfs41_setup_sequence(struct nfs4_session
*session
,
282 struct nfs4_sequence_args
*args
, struct nfs4_sequence_res
*res
,
283 struct rpc_task
*task
);
284 extern int nfs41_sequence_done(struct rpc_task
*, struct nfs4_sequence_res
*);
285 extern int nfs4_proc_create_session(struct nfs_client
*, struct rpc_cred
*);
286 extern int nfs4_proc_destroy_session(struct nfs4_session
*, struct rpc_cred
*);
287 extern int nfs4_proc_get_lease_time(struct nfs_client
*clp
,
288 struct nfs_fsinfo
*fsinfo
);
289 extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data
*data
,
291 extern int nfs4_detect_session_trunking(struct nfs_client
*clp
,
292 struct nfs41_exchange_id_res
*res
, struct rpc_xprt
*xprt
);
295 is_ds_only_client(struct nfs_client
*clp
)
297 return (clp
->cl_exchange_flags
& EXCHGID4_FLAG_MASK_PNFS
) ==
298 EXCHGID4_FLAG_USE_PNFS_DS
;
302 is_ds_client(struct nfs_client
*clp
)
304 return clp
->cl_exchange_flags
& EXCHGID4_FLAG_USE_PNFS_DS
;
308 _nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_mode
,
309 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
311 struct rpc_cred
*newcred
= NULL
;
312 rpc_authflavor_t flavor
;
314 if (test_bit(sp4_mode
, &clp
->cl_sp4_flags
)) {
315 spin_lock(&clp
->cl_lock
);
316 if (clp
->cl_machine_cred
!= NULL
)
317 /* don't call get_rpccred on the machine cred -
318 * a reference will be held for life of clp */
319 newcred
= clp
->cl_machine_cred
;
320 spin_unlock(&clp
->cl_lock
);
321 msg
->rpc_cred
= newcred
;
323 flavor
= clp
->cl_rpcclient
->cl_auth
->au_flavor
;
324 WARN_ON_ONCE(flavor
!= RPC_AUTH_GSS_KRB5I
&&
325 flavor
!= RPC_AUTH_GSS_KRB5P
);
326 *clntp
= clp
->cl_rpcclient
;
334 * Function responsible for determining if an rpc_message should use the
335 * machine cred under SP4_MACH_CRED and if so switching the credential and
336 * authflavor (using the nfs_client's rpc_clnt which will be krb5i/p).
337 * Should be called before rpc_call_sync/rpc_call_async.
340 nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_mode
,
341 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
343 _nfs4_state_protect(clp
, sp4_mode
, clntp
, msg
);
347 * Special wrapper to nfs4_state_protect for write.
348 * If WRITE can use machine cred but COMMIT cannot, make sure all writes
349 * that use machine cred use NFS_FILE_SYNC.
352 nfs4_state_protect_write(struct nfs_client
*clp
, struct rpc_clnt
**clntp
,
353 struct rpc_message
*msg
, struct nfs_pgio_header
*hdr
)
355 if (_nfs4_state_protect(clp
, NFS_SP4_MACH_CRED_WRITE
, clntp
, msg
) &&
356 !test_bit(NFS_SP4_MACH_CRED_COMMIT
, &clp
->cl_sp4_flags
))
357 hdr
->args
.stable
= NFS_FILE_SYNC
;
359 #else /* CONFIG_NFS_v4_1 */
360 static inline struct nfs4_session
*nfs4_get_session(const struct nfs_server
*server
)
366 is_ds_only_client(struct nfs_client
*clp
)
372 is_ds_client(struct nfs_client
*clp
)
378 nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_flags
,
379 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
384 nfs4_state_protect_write(struct nfs_client
*clp
, struct rpc_clnt
**clntp
,
385 struct rpc_message
*msg
, struct nfs_pgio_header
*hdr
)
388 #endif /* CONFIG_NFS_V4_1 */
390 extern const struct nfs4_minor_version_ops
*nfs_v4_minor_ops
[];
392 extern const u32 nfs4_fattr_bitmap
[3];
393 extern const u32 nfs4_statfs_bitmap
[3];
394 extern const u32 nfs4_pathconf_bitmap
[3];
395 extern const u32 nfs4_fsinfo_bitmap
[3];
396 extern const u32 nfs4_fs_locations_bitmap
[3];
398 void nfs40_shutdown_client(struct nfs_client
*);
399 void nfs41_shutdown_client(struct nfs_client
*);
400 int nfs40_init_client(struct nfs_client
*);
401 int nfs41_init_client(struct nfs_client
*);
402 void nfs4_free_client(struct nfs_client
*);
404 struct nfs_client
*nfs4_alloc_client(const struct nfs_client_initdata
*);
407 extern void nfs4_schedule_state_renewal(struct nfs_client
*);
408 extern void nfs4_renewd_prepare_shutdown(struct nfs_server
*);
409 extern void nfs4_kill_renewd(struct nfs_client
*);
410 extern void nfs4_renew_state(struct work_struct
*);
411 extern void nfs4_set_lease_period(struct nfs_client
*clp
,
413 unsigned long lastrenewed
);
417 struct rpc_cred
*nfs4_get_clid_cred(struct nfs_client
*clp
);
418 struct rpc_cred
*nfs4_get_machine_cred_locked(struct nfs_client
*clp
);
419 struct rpc_cred
*nfs4_get_renew_cred_locked(struct nfs_client
*clp
);
420 int nfs4_discover_server_trunking(struct nfs_client
*clp
,
421 struct nfs_client
**);
422 int nfs40_discover_server_trunking(struct nfs_client
*clp
,
423 struct nfs_client
**, struct rpc_cred
*);
424 #if defined(CONFIG_NFS_V4_1)
425 int nfs41_discover_server_trunking(struct nfs_client
*clp
,
426 struct nfs_client
**, struct rpc_cred
*);
427 extern void nfs4_schedule_session_recovery(struct nfs4_session
*, int);
428 extern void nfs41_notify_server(struct nfs_client
*);
430 static inline void nfs4_schedule_session_recovery(struct nfs4_session
*session
, int err
)
433 #endif /* CONFIG_NFS_V4_1 */
435 extern struct nfs4_state_owner
*nfs4_get_state_owner(struct nfs_server
*, struct rpc_cred
*, gfp_t
);
436 extern void nfs4_put_state_owner(struct nfs4_state_owner
*);
437 extern void nfs4_purge_state_owners(struct nfs_server
*);
438 extern struct nfs4_state
* nfs4_get_open_state(struct inode
*, struct nfs4_state_owner
*);
439 extern void nfs4_put_open_state(struct nfs4_state
*);
440 extern void nfs4_close_state(struct nfs4_state
*, fmode_t
);
441 extern void nfs4_close_sync(struct nfs4_state
*, fmode_t
);
442 extern void nfs4_state_set_mode_locked(struct nfs4_state
*, fmode_t
);
443 extern void nfs_inode_find_state_and_recover(struct inode
*inode
,
444 const nfs4_stateid
*stateid
);
445 extern int nfs4_state_mark_reclaim_nograce(struct nfs_client
*, struct nfs4_state
*);
446 extern void nfs4_schedule_lease_recovery(struct nfs_client
*);
447 extern int nfs4_wait_clnt_recover(struct nfs_client
*clp
);
448 extern int nfs4_client_recover_expired_lease(struct nfs_client
*clp
);
449 extern void nfs4_schedule_state_manager(struct nfs_client
*);
450 extern void nfs4_schedule_path_down_recovery(struct nfs_client
*clp
);
451 extern int nfs4_schedule_stateid_recovery(const struct nfs_server
*, struct nfs4_state
*);
452 extern int nfs4_schedule_migration_recovery(const struct nfs_server
*);
453 extern void nfs4_schedule_lease_moved_recovery(struct nfs_client
*);
454 extern void nfs41_handle_sequence_flag_errors(struct nfs_client
*clp
, u32 flags
, bool);
455 extern void nfs41_handle_server_scope(struct nfs_client
*,
456 struct nfs41_server_scope
**);
457 extern void nfs4_put_lock_state(struct nfs4_lock_state
*lsp
);
458 extern int nfs4_set_lock_state(struct nfs4_state
*state
, struct file_lock
*fl
);
459 extern int nfs4_select_rw_stateid(struct nfs4_state
*, fmode_t
,
460 const struct nfs_lock_context
*, nfs4_stateid
*,
463 extern struct nfs_seqid
*nfs_alloc_seqid(struct nfs_seqid_counter
*counter
, gfp_t gfp_mask
);
464 extern int nfs_wait_on_sequence(struct nfs_seqid
*seqid
, struct rpc_task
*task
);
465 extern void nfs_increment_open_seqid(int status
, struct nfs_seqid
*seqid
);
466 extern void nfs_increment_lock_seqid(int status
, struct nfs_seqid
*seqid
);
467 extern void nfs_release_seqid(struct nfs_seqid
*seqid
);
468 extern void nfs_free_seqid(struct nfs_seqid
*seqid
);
469 extern int nfs40_setup_sequence(struct nfs4_slot_table
*tbl
,
470 struct nfs4_sequence_args
*args
,
471 struct nfs4_sequence_res
*res
,
472 struct rpc_task
*task
);
473 extern int nfs4_sequence_done(struct rpc_task
*task
,
474 struct nfs4_sequence_res
*res
);
476 extern void nfs4_free_lock_state(struct nfs_server
*server
, struct nfs4_lock_state
*lsp
);
478 extern const nfs4_stateid zero_stateid
;
481 struct nfs_mount_info
;
482 extern struct nfs_subversion nfs_v4
;
483 struct dentry
*nfs4_try_mount(int, const char *, struct nfs_mount_info
*, struct nfs_subversion
*);
484 extern bool nfs4_disable_idmapping
;
485 extern unsigned short max_session_slots
;
486 extern unsigned short max_session_cb_slots
;
487 extern unsigned short send_implementation_id
;
488 extern bool recover_lost_locks
;
490 #define NFS4_CLIENT_ID_UNIQ_LEN (64)
491 extern char nfs4_client_id_uniquifier
[NFS4_CLIENT_ID_UNIQ_LEN
];
495 int nfs4_register_sysctl(void);
496 void nfs4_unregister_sysctl(void);
498 static inline int nfs4_register_sysctl(void)
503 static inline void nfs4_unregister_sysctl(void)
509 extern struct rpc_procinfo nfs4_procedures
[];
511 struct nfs4_mount_data
;
514 extern struct svc_version nfs4_callback_version1
;
515 extern struct svc_version nfs4_callback_version4
;
517 static inline void nfs4_stateid_copy(nfs4_stateid
*dst
, const nfs4_stateid
*src
)
519 memcpy(dst
->data
, src
->data
, sizeof(dst
->data
));
520 dst
->type
= src
->type
;
523 static inline bool nfs4_stateid_match(const nfs4_stateid
*dst
, const nfs4_stateid
*src
)
525 if (dst
->type
!= src
->type
)
527 return memcmp(dst
->data
, src
->data
, sizeof(dst
->data
)) == 0;
530 static inline bool nfs4_stateid_match_other(const nfs4_stateid
*dst
, const nfs4_stateid
*src
)
532 return memcmp(dst
->other
, src
->other
, NFS4_STATEID_OTHER_SIZE
) == 0;
535 static inline bool nfs4_stateid_is_newer(const nfs4_stateid
*s1
, const nfs4_stateid
*s2
)
537 return (s32
)(be32_to_cpu(s1
->seqid
) - be32_to_cpu(s2
->seqid
)) > 0;
540 static inline bool nfs4_valid_open_stateid(const struct nfs4_state
*state
)
542 return test_bit(NFS_STATE_RECOVERY_FAILED
, &state
->flags
) == 0;
545 static inline bool nfs4_state_match_open_stateid_other(const struct nfs4_state
*state
,
546 const nfs4_stateid
*stateid
)
548 return test_bit(NFS_OPEN_STATE
, &state
->flags
) &&
549 nfs4_stateid_match_other(&state
->open_stateid
, stateid
);
554 #define nfs4_close_state(a, b) do { } while (0)
555 #define nfs4_close_sync(a, b) do { } while (0)
556 #define nfs4_state_protect(a, b, c, d) do { } while (0)
557 #define nfs4_state_protect_write(a, b, c, d) do { } while (0)
559 #endif /* CONFIG_NFS_V4 */
560 #endif /* __LINUX_FS_NFS_NFS4_FS.H */