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 IS_ENABLED(CONFIG_NFS_V4)
14 #define NFS4_MAX_LOOP_ON_RECOVER (10)
16 #include <linux/seqlock.h>
20 enum nfs4_client_state
{
21 NFS4CLNT_MANAGER_RUNNING
= 0,
23 NFS4CLNT_LEASE_EXPIRED
,
24 NFS4CLNT_RECLAIM_REBOOT
,
25 NFS4CLNT_RECLAIM_NOGRACE
,
27 NFS4CLNT_SESSION_RESET
,
28 NFS4CLNT_LEASE_CONFIRM
,
29 NFS4CLNT_SERVER_SCOPE_MISMATCH
,
31 NFS4CLNT_BIND_CONN_TO_SESSION
,
36 #define NFS4_RENEW_TIMEOUT 0x01
37 #define NFS4_RENEW_DELEGATION_CB 0x02
39 struct nfs4_minor_version_ops
{
43 int (*init_client
)(struct nfs_client
*);
44 void (*shutdown_client
)(struct nfs_client
*);
45 bool (*match_stateid
)(const nfs4_stateid
*,
46 const nfs4_stateid
*);
47 int (*find_root_sec
)(struct nfs_server
*, struct nfs_fh
*,
49 int (*free_lock_state
)(struct nfs_server
*,
50 struct nfs4_lock_state
*);
51 const struct rpc_call_ops
*call_sync_ops
;
52 const struct nfs4_state_recovery_ops
*reboot_recovery_ops
;
53 const struct nfs4_state_recovery_ops
*nograce_recovery_ops
;
54 const struct nfs4_state_maintenance_ops
*state_renewal_ops
;
55 const struct nfs4_mig_recovery_ops
*mig_recovery_ops
;
58 #define NFS_SEQID_CONFIRMED 1
59 struct nfs_seqid_counter
{
64 spinlock_t lock
; /* Protects the list */
65 struct list_head list
; /* Defines sequence of RPC calls */
66 struct rpc_wait_queue wait
; /* RPC call delay queue */
70 struct nfs_seqid_counter
*sequence
;
71 struct list_head list
;
72 struct rpc_task
*task
;
75 static inline void nfs_confirm_seqid(struct nfs_seqid_counter
*seqid
, int status
)
77 if (seqid_mutating_err(-status
))
78 seqid
->flags
|= NFS_SEQID_CONFIRMED
;
82 * NFS4 state_owners and lock_owners are simply labels for ordered
83 * sequences of RPC calls. Their sole purpose is to provide once-only
84 * semantics by allowing the server to identify replayed requests.
86 struct nfs4_state_owner
{
87 struct nfs_server
*so_server
;
88 struct list_head so_lru
;
89 unsigned long so_expires
;
90 struct rb_node so_server_node
;
92 struct rpc_cred
*so_cred
; /* Associated cred */
96 unsigned long so_flags
;
97 struct list_head so_states
;
98 struct nfs_seqid_counter so_seqid
;
99 seqcount_t so_reclaim_seqcount
;
100 struct mutex so_delegreturn_mutex
;
104 NFS_OWNER_RECLAIM_REBOOT
,
105 NFS_OWNER_RECLAIM_NOGRACE
108 #define NFS_LOCK_NEW 0
109 #define NFS_LOCK_RECLAIM 1
110 #define NFS_LOCK_EXPIRED 2
113 * struct nfs4_state maintains the client-side state for a given
114 * (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
117 * In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
118 * we need to know how many files are open for reading or writing on a
119 * given inode. This information too is stored here.
121 * LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
124 struct nfs4_lock_owner
{
125 unsigned int lo_type
;
126 #define NFS4_ANY_LOCK_TYPE (0U)
127 #define NFS4_FLOCK_LOCK_TYPE (1U << 0)
128 #define NFS4_POSIX_LOCK_TYPE (1U << 1)
130 fl_owner_t posix_owner
;
135 struct nfs4_lock_state
{
136 struct list_head ls_locks
; /* Other lock stateids */
137 struct nfs4_state
* ls_state
; /* Pointer to open state */
138 #define NFS_LOCK_INITIALIZED 0
139 #define NFS_LOCK_LOST 1
140 unsigned long ls_flags
;
141 struct nfs_seqid_counter ls_seqid
;
142 nfs4_stateid ls_stateid
;
144 struct nfs4_lock_owner ls_owner
;
147 /* bits for nfs4_state->flags */
150 NFS_DELEGATED_STATE
, /* Current stateid is delegation */
151 NFS_OPEN_STATE
, /* OPEN stateid is set */
152 NFS_O_RDONLY_STATE
, /* OPEN stateid has read-only state */
153 NFS_O_WRONLY_STATE
, /* OPEN stateid has write-only state */
154 NFS_O_RDWR_STATE
, /* OPEN stateid has read/write state */
155 NFS_STATE_RECLAIM_REBOOT
, /* OPEN stateid server rebooted */
156 NFS_STATE_RECLAIM_NOGRACE
, /* OPEN stateid needs to recover state */
157 NFS_STATE_POSIX_LOCKS
, /* Posix locks are supported */
158 NFS_STATE_RECOVERY_FAILED
, /* OPEN stateid state recovery failed */
162 struct list_head open_states
; /* List of states for the same state_owner */
163 struct list_head inode_states
; /* List of states for the same inode */
164 struct list_head lock_states
; /* List of subservient lock stateids */
166 struct nfs4_state_owner
*owner
; /* Pointer to the open owner */
167 struct inode
*inode
; /* Pointer to the inode */
169 unsigned long flags
; /* Do we hold any locks? */
170 spinlock_t state_lock
; /* Protects the lock_states list */
172 seqlock_t seqlock
; /* Protects the stateid/open_stateid */
173 nfs4_stateid stateid
; /* Current stateid: may be delegation */
174 nfs4_stateid open_stateid
; /* OPEN stateid */
176 /* The following 3 fields are protected by owner->so_lock */
177 unsigned int n_rdonly
; /* Number of read-only references */
178 unsigned int n_wronly
; /* Number of write-only references */
179 unsigned int n_rdwr
; /* Number of read/write references */
180 fmode_t state
; /* State on the server (R,W, or RW) */
185 struct nfs4_exception
{
188 struct nfs4_state
*state
;
192 struct nfs4_state_recovery_ops
{
195 int (*recover_open
)(struct nfs4_state_owner
*, struct nfs4_state
*);
196 int (*recover_lock
)(struct nfs4_state
*, struct file_lock
*);
197 int (*establish_clid
)(struct nfs_client
*, struct rpc_cred
*);
198 int (*reclaim_complete
)(struct nfs_client
*, struct rpc_cred
*);
199 int (*detect_trunking
)(struct nfs_client
*, struct nfs_client
**,
203 struct nfs4_state_maintenance_ops
{
204 int (*sched_state_renewal
)(struct nfs_client
*, struct rpc_cred
*, unsigned);
205 struct rpc_cred
* (*get_state_renewal_cred_locked
)(struct nfs_client
*);
206 int (*renew_lease
)(struct nfs_client
*, struct rpc_cred
*);
209 struct nfs4_mig_recovery_ops
{
210 int (*get_locations
)(struct inode
*, struct nfs4_fs_locations
*,
211 struct page
*, struct rpc_cred
*);
212 int (*fsid_present
)(struct inode
*, struct rpc_cred
*);
215 extern const struct dentry_operations nfs4_dentry_operations
;
218 int nfs_atomic_open(struct inode
*, struct dentry
*, struct file
*,
219 unsigned, umode_t
, int *);
222 extern struct file_system_type nfs4_fs_type
;
224 /* nfs4namespace.c */
225 struct rpc_clnt
*nfs4_create_sec_client(struct rpc_clnt
*, struct inode
*, struct qstr
*);
226 struct vfsmount
*nfs4_submount(struct nfs_server
*, struct dentry
*,
227 struct nfs_fh
*, struct nfs_fattr
*);
228 int nfs4_replace_transport(struct nfs_server
*server
,
229 const struct nfs4_fs_locations
*locations
);
232 extern int nfs4_proc_setclientid(struct nfs_client
*, u32
, unsigned short, struct rpc_cred
*, struct nfs4_setclientid_res
*);
233 extern int nfs4_proc_setclientid_confirm(struct nfs_client
*, struct nfs4_setclientid_res
*arg
, struct rpc_cred
*);
234 extern int nfs4_proc_get_rootfh(struct nfs_server
*, struct nfs_fh
*, struct nfs_fsinfo
*, bool);
235 extern int nfs4_proc_bind_conn_to_session(struct nfs_client
*, struct rpc_cred
*cred
);
236 extern int nfs4_proc_exchange_id(struct nfs_client
*clp
, struct rpc_cred
*cred
);
237 extern int nfs4_destroy_clientid(struct nfs_client
*clp
);
238 extern int nfs4_init_clientid(struct nfs_client
*, struct rpc_cred
*);
239 extern int nfs41_init_clientid(struct nfs_client
*, struct rpc_cred
*);
240 extern int nfs4_do_close(struct nfs4_state
*state
, gfp_t gfp_mask
, int wait
);
241 extern int nfs4_server_capabilities(struct nfs_server
*server
, struct nfs_fh
*fhandle
);
242 extern int nfs4_proc_fs_locations(struct rpc_clnt
*, struct inode
*, const struct qstr
*,
243 struct nfs4_fs_locations
*, struct page
*);
244 extern int nfs4_proc_get_locations(struct inode
*, struct nfs4_fs_locations
*,
245 struct page
*page
, struct rpc_cred
*);
246 extern int nfs4_proc_fsid_present(struct inode
*, struct rpc_cred
*);
247 extern struct rpc_clnt
*nfs4_proc_lookup_mountpoint(struct inode
*, struct qstr
*,
248 struct nfs_fh
*, struct nfs_fattr
*);
249 extern int nfs4_proc_secinfo(struct inode
*, const struct qstr
*, struct nfs4_secinfo_flavors
*);
250 extern const struct xattr_handler
*nfs4_xattr_handlers
[];
251 extern int nfs4_set_rw_stateid(nfs4_stateid
*stateid
,
252 const struct nfs_open_context
*ctx
,
253 const struct nfs_lock_context
*l_ctx
,
256 #if defined(CONFIG_NFS_V4_1)
257 static inline struct nfs4_session
*nfs4_get_session(const struct nfs_server
*server
)
259 return server
->nfs_client
->cl_session
;
262 extern int nfs41_setup_sequence(struct nfs4_session
*session
,
263 struct nfs4_sequence_args
*args
, struct nfs4_sequence_res
*res
,
264 struct rpc_task
*task
);
265 extern int nfs4_proc_create_session(struct nfs_client
*, struct rpc_cred
*);
266 extern int nfs4_proc_destroy_session(struct nfs4_session
*, struct rpc_cred
*);
267 extern int nfs4_proc_get_lease_time(struct nfs_client
*clp
,
268 struct nfs_fsinfo
*fsinfo
);
269 extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data
*data
,
273 is_ds_only_client(struct nfs_client
*clp
)
275 return (clp
->cl_exchange_flags
& EXCHGID4_FLAG_MASK_PNFS
) ==
276 EXCHGID4_FLAG_USE_PNFS_DS
;
280 is_ds_client(struct nfs_client
*clp
)
282 return clp
->cl_exchange_flags
& EXCHGID4_FLAG_USE_PNFS_DS
;
286 _nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_mode
,
287 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
289 struct rpc_cred
*newcred
= NULL
;
290 rpc_authflavor_t flavor
;
292 if (test_bit(sp4_mode
, &clp
->cl_sp4_flags
)) {
293 spin_lock(&clp
->cl_lock
);
294 if (clp
->cl_machine_cred
!= NULL
)
295 /* don't call get_rpccred on the machine cred -
296 * a reference will be held for life of clp */
297 newcred
= clp
->cl_machine_cred
;
298 spin_unlock(&clp
->cl_lock
);
299 msg
->rpc_cred
= newcred
;
301 flavor
= clp
->cl_rpcclient
->cl_auth
->au_flavor
;
302 WARN_ON_ONCE(flavor
!= RPC_AUTH_GSS_KRB5I
&&
303 flavor
!= RPC_AUTH_GSS_KRB5P
);
304 *clntp
= clp
->cl_rpcclient
;
312 * Function responsible for determining if an rpc_message should use the
313 * machine cred under SP4_MACH_CRED and if so switching the credential and
314 * authflavor (using the nfs_client's rpc_clnt which will be krb5i/p).
315 * Should be called before rpc_call_sync/rpc_call_async.
318 nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_mode
,
319 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
321 _nfs4_state_protect(clp
, sp4_mode
, clntp
, msg
);
325 * Special wrapper to nfs4_state_protect for write.
326 * If WRITE can use machine cred but COMMIT cannot, make sure all writes
327 * that use machine cred use NFS_FILE_SYNC.
330 nfs4_state_protect_write(struct nfs_client
*clp
, struct rpc_clnt
**clntp
,
331 struct rpc_message
*msg
, struct nfs_write_data
*wdata
)
333 if (_nfs4_state_protect(clp
, NFS_SP4_MACH_CRED_WRITE
, clntp
, msg
) &&
334 !test_bit(NFS_SP4_MACH_CRED_COMMIT
, &clp
->cl_sp4_flags
))
335 wdata
->args
.stable
= NFS_FILE_SYNC
;
337 #else /* CONFIG_NFS_v4_1 */
338 static inline struct nfs4_session
*nfs4_get_session(const struct nfs_server
*server
)
344 is_ds_only_client(struct nfs_client
*clp
)
350 is_ds_client(struct nfs_client
*clp
)
356 nfs4_state_protect(struct nfs_client
*clp
, unsigned long sp4_flags
,
357 struct rpc_clnt
**clntp
, struct rpc_message
*msg
)
362 nfs4_state_protect_write(struct nfs_client
*clp
, struct rpc_clnt
**clntp
,
363 struct rpc_message
*msg
, struct nfs_write_data
*wdata
)
366 #endif /* CONFIG_NFS_V4_1 */
368 extern const struct nfs4_minor_version_ops
*nfs_v4_minor_ops
[];
370 extern const u32 nfs4_fattr_bitmap
[3];
371 extern const u32 nfs4_statfs_bitmap
[3];
372 extern const u32 nfs4_pathconf_bitmap
[3];
373 extern const u32 nfs4_fsinfo_bitmap
[3];
374 extern const u32 nfs4_fs_locations_bitmap
[3];
376 void nfs40_shutdown_client(struct nfs_client
*);
377 void nfs41_shutdown_client(struct nfs_client
*);
378 int nfs40_init_client(struct nfs_client
*);
379 int nfs41_init_client(struct nfs_client
*);
380 void nfs4_free_client(struct nfs_client
*);
382 struct nfs_client
*nfs4_alloc_client(const struct nfs_client_initdata
*);
385 extern void nfs4_schedule_state_renewal(struct nfs_client
*);
386 extern void nfs4_renewd_prepare_shutdown(struct nfs_server
*);
387 extern void nfs4_kill_renewd(struct nfs_client
*);
388 extern void nfs4_renew_state(struct work_struct
*);
391 struct rpc_cred
*nfs4_get_clid_cred(struct nfs_client
*clp
);
392 struct rpc_cred
*nfs4_get_machine_cred_locked(struct nfs_client
*clp
);
393 struct rpc_cred
*nfs4_get_renew_cred_locked(struct nfs_client
*clp
);
394 int nfs4_discover_server_trunking(struct nfs_client
*clp
,
395 struct nfs_client
**);
396 int nfs40_discover_server_trunking(struct nfs_client
*clp
,
397 struct nfs_client
**, struct rpc_cred
*);
398 #if defined(CONFIG_NFS_V4_1)
399 int nfs41_discover_server_trunking(struct nfs_client
*clp
,
400 struct nfs_client
**, struct rpc_cred
*);
401 extern void nfs4_schedule_session_recovery(struct nfs4_session
*, int);
402 extern void nfs41_server_notify_target_slotid_update(struct nfs_client
*clp
);
403 extern void nfs41_server_notify_highest_slotid_update(struct nfs_client
*clp
);
406 static inline void nfs4_schedule_session_recovery(struct nfs4_session
*session
, int err
)
409 #endif /* CONFIG_NFS_V4_1 */
411 extern struct nfs4_state_owner
*nfs4_get_state_owner(struct nfs_server
*, struct rpc_cred
*, gfp_t
);
412 extern void nfs4_put_state_owner(struct nfs4_state_owner
*);
413 extern void nfs4_purge_state_owners(struct nfs_server
*);
414 extern struct nfs4_state
* nfs4_get_open_state(struct inode
*, struct nfs4_state_owner
*);
415 extern void nfs4_put_open_state(struct nfs4_state
*);
416 extern void nfs4_close_state(struct nfs4_state
*, fmode_t
);
417 extern void nfs4_close_sync(struct nfs4_state
*, fmode_t
);
418 extern void nfs4_state_set_mode_locked(struct nfs4_state
*, fmode_t
);
419 extern void nfs_inode_find_state_and_recover(struct inode
*inode
,
420 const nfs4_stateid
*stateid
);
421 extern void nfs4_schedule_lease_recovery(struct nfs_client
*);
422 extern int nfs4_wait_clnt_recover(struct nfs_client
*clp
);
423 extern int nfs4_client_recover_expired_lease(struct nfs_client
*clp
);
424 extern void nfs4_schedule_state_manager(struct nfs_client
*);
425 extern void nfs4_schedule_path_down_recovery(struct nfs_client
*clp
);
426 extern int nfs4_schedule_stateid_recovery(const struct nfs_server
*, struct nfs4_state
*);
427 extern int nfs4_schedule_migration_recovery(const struct nfs_server
*);
428 extern void nfs4_schedule_lease_moved_recovery(struct nfs_client
*);
429 extern void nfs41_handle_sequence_flag_errors(struct nfs_client
*clp
, u32 flags
);
430 extern void nfs41_handle_server_scope(struct nfs_client
*,
431 struct nfs41_server_scope
**);
432 extern void nfs4_put_lock_state(struct nfs4_lock_state
*lsp
);
433 extern int nfs4_set_lock_state(struct nfs4_state
*state
, struct file_lock
*fl
);
434 extern int nfs4_select_rw_stateid(nfs4_stateid
*, struct nfs4_state
*,
435 fmode_t
, const struct nfs_lockowner
*);
437 extern struct nfs_seqid
*nfs_alloc_seqid(struct nfs_seqid_counter
*counter
, gfp_t gfp_mask
);
438 extern int nfs_wait_on_sequence(struct nfs_seqid
*seqid
, struct rpc_task
*task
);
439 extern void nfs_increment_open_seqid(int status
, struct nfs_seqid
*seqid
);
440 extern void nfs_increment_lock_seqid(int status
, struct nfs_seqid
*seqid
);
441 extern void nfs_release_seqid(struct nfs_seqid
*seqid
);
442 extern void nfs_free_seqid(struct nfs_seqid
*seqid
);
444 extern void nfs4_free_lock_state(struct nfs_server
*server
, struct nfs4_lock_state
*lsp
);
446 extern const nfs4_stateid zero_stateid
;
449 struct nfs_mount_info
;
450 extern struct nfs_subversion nfs_v4
;
451 struct dentry
*nfs4_try_mount(int, const char *, struct nfs_mount_info
*, struct nfs_subversion
*);
452 extern bool nfs4_disable_idmapping
;
453 extern unsigned short max_session_slots
;
454 extern unsigned short send_implementation_id
;
455 extern bool recover_lost_locks
;
457 #define NFS4_CLIENT_ID_UNIQ_LEN (64)
458 extern char nfs4_client_id_uniquifier
[NFS4_CLIENT_ID_UNIQ_LEN
];
462 int nfs4_register_sysctl(void);
463 void nfs4_unregister_sysctl(void);
465 static inline int nfs4_register_sysctl(void)
470 static inline void nfs4_unregister_sysctl(void)
476 extern struct rpc_procinfo nfs4_procedures
[];
478 struct nfs4_mount_data
;
481 extern struct svc_version nfs4_callback_version1
;
482 extern struct svc_version nfs4_callback_version4
;
484 static inline void nfs4_stateid_copy(nfs4_stateid
*dst
, const nfs4_stateid
*src
)
486 memcpy(dst
, src
, sizeof(*dst
));
489 static inline bool nfs4_stateid_match(const nfs4_stateid
*dst
, const nfs4_stateid
*src
)
491 return memcmp(dst
, src
, sizeof(*dst
)) == 0;
494 static inline bool nfs4_valid_open_stateid(const struct nfs4_state
*state
)
496 return test_bit(NFS_STATE_RECOVERY_FAILED
, &state
->flags
) == 0;
501 #define nfs4_close_state(a, b) do { } while (0)
502 #define nfs4_close_sync(a, b) do { } while (0)
503 #define nfs4_state_protect(a, b, c, d) do { } while (0)
504 #define nfs4_state_protect_write(a, b, c, d) do { } while (0)
506 #endif /* CONFIG_NFS_V4 */
507 #endif /* __LINUX_FS_NFS_NFS4_FS.H */