1
2
3
4
5
6
7
8
9#ifndef __LINUX_FS_NFS_NFS4_FS_H
10#define __LINUX_FS_NFS_NFS4_FS_H
11
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
16#else
17#define NFS4_MAX_MINOR_VERSION 0
18#endif
19
20#if IS_ENABLED(CONFIG_NFS_V4)
21
22#define NFS4_MAX_LOOP_ON_RECOVER (10)
23
24#include <linux/seqlock.h>
25
26struct idmap;
27
28enum nfs4_client_state {
29 NFS4CLNT_MANAGER_RUNNING = 0,
30 NFS4CLNT_CHECK_LEASE,
31 NFS4CLNT_LEASE_EXPIRED,
32 NFS4CLNT_RECLAIM_REBOOT,
33 NFS4CLNT_RECLAIM_NOGRACE,
34 NFS4CLNT_DELEGRETURN,
35 NFS4CLNT_SESSION_RESET,
36 NFS4CLNT_LEASE_CONFIRM,
37 NFS4CLNT_SERVER_SCOPE_MISMATCH,
38 NFS4CLNT_PURGE_STATE,
39 NFS4CLNT_BIND_CONN_TO_SESSION,
40 NFS4CLNT_MOVED,
41 NFS4CLNT_LEASE_MOVED,
42};
43
44#define NFS4_RENEW_TIMEOUT 0x01
45#define NFS4_RENEW_DELEGATION_CB 0x02
46
47struct nfs4_minor_version_ops {
48 u32 minor_version;
49 unsigned init_caps;
50
51 int (*init_client)(struct nfs_client *);
52 void (*shutdown_client)(struct nfs_client *);
53 bool (*match_stateid)(const nfs4_stateid *,
54 const nfs4_stateid *);
55 int (*find_root_sec)(struct nfs_server *, struct nfs_fh *,
56 struct nfs_fsinfo *);
57 void (*free_lock_state)(struct nfs_server *,
58 struct nfs4_lock_state *);
59 const struct rpc_call_ops *call_sync_ops;
60 const struct nfs4_state_recovery_ops *reboot_recovery_ops;
61 const struct nfs4_state_recovery_ops *nograce_recovery_ops;
62 const struct nfs4_state_maintenance_ops *state_renewal_ops;
63 const struct nfs4_mig_recovery_ops *mig_recovery_ops;
64};
65
66#define NFS_SEQID_CONFIRMED 1
67struct nfs_seqid_counter {
68 ktime_t create_time;
69 int owner_id;
70 int flags;
71 u32 counter;
72 spinlock_t lock;
73 struct list_head list;
74 struct rpc_wait_queue wait;
75};
76
77struct nfs_seqid {
78 struct nfs_seqid_counter *sequence;
79 struct list_head list;
80 struct rpc_task *task;
81};
82
83static inline void nfs_confirm_seqid(struct nfs_seqid_counter *seqid, int status)
84{
85 if (seqid_mutating_err(-status))
86 seqid->flags |= NFS_SEQID_CONFIRMED;
87}
88
89
90
91
92
93
94struct nfs4_state_owner {
95 struct nfs_server *so_server;
96 struct list_head so_lru;
97 unsigned long so_expires;
98 struct rb_node so_server_node;
99
100 struct rpc_cred *so_cred;
101
102 spinlock_t so_lock;
103 atomic_t so_count;
104 unsigned long so_flags;
105 struct list_head so_states;
106 struct nfs_seqid_counter so_seqid;
107 seqcount_t so_reclaim_seqcount;
108 struct mutex so_delegreturn_mutex;
109};
110
111enum {
112 NFS_OWNER_RECLAIM_REBOOT,
113 NFS_OWNER_RECLAIM_NOGRACE
114};
115
116#define NFS_LOCK_NEW 0
117#define NFS_LOCK_RECLAIM 1
118#define NFS_LOCK_EXPIRED 2
119
120
121
122
123
124
125
126
127
128
129
130
131
132struct nfs4_lock_state {
133 struct list_head ls_locks;
134 struct nfs4_state * ls_state;
135#define NFS_LOCK_INITIALIZED 0
136#define NFS_LOCK_LOST 1
137 unsigned long ls_flags;
138 struct nfs_seqid_counter ls_seqid;
139 nfs4_stateid ls_stateid;
140 atomic_t ls_count;
141 fl_owner_t ls_owner;
142};
143
144
145enum {
146 LK_STATE_IN_USE,
147 NFS_DELEGATED_STATE,
148 NFS_OPEN_STATE,
149 NFS_O_RDONLY_STATE,
150 NFS_O_WRONLY_STATE,
151 NFS_O_RDWR_STATE,
152 NFS_STATE_RECLAIM_REBOOT,
153 NFS_STATE_RECLAIM_NOGRACE,
154 NFS_STATE_POSIX_LOCKS,
155 NFS_STATE_RECOVERY_FAILED,
156};
157
158struct nfs4_state {
159 struct list_head open_states;
160 struct list_head inode_states;
161 struct list_head lock_states;
162
163 struct nfs4_state_owner *owner;
164 struct inode *inode;
165
166 unsigned long flags;
167 spinlock_t state_lock;
168
169 seqlock_t seqlock;
170 nfs4_stateid stateid;
171 nfs4_stateid open_stateid;
172
173
174 unsigned int n_rdonly;
175 unsigned int n_wronly;
176 unsigned int n_rdwr;
177 fmode_t state;
178 atomic_t count;
179};
180
181
182struct nfs4_exception {
183 long timeout;
184 int retry;
185 struct nfs4_state *state;
186 struct inode *inode;
187};
188
189struct nfs4_state_recovery_ops {
190 int owner_flag_bit;
191 int state_flag_bit;
192 int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *);
193 int (*recover_lock)(struct nfs4_state *, struct file_lock *);
194 int (*establish_clid)(struct nfs_client *, struct rpc_cred *);
195 int (*reclaim_complete)(struct nfs_client *, struct rpc_cred *);
196 int (*detect_trunking)(struct nfs_client *, struct nfs_client **,
197 struct rpc_cred *);
198};
199
200struct nfs4_state_maintenance_ops {
201 int (*sched_state_renewal)(struct nfs_client *, struct rpc_cred *, unsigned);
202 struct rpc_cred * (*get_state_renewal_cred_locked)(struct nfs_client *);
203 int (*renew_lease)(struct nfs_client *, struct rpc_cred *);
204};
205
206struct nfs4_mig_recovery_ops {
207 int (*get_locations)(struct inode *, struct nfs4_fs_locations *,
208 struct page *, struct rpc_cred *);
209 int (*fsid_present)(struct inode *, struct rpc_cred *);
210};
211
212extern const struct dentry_operations nfs4_dentry_operations;
213
214
215int nfs_atomic_open(struct inode *, struct dentry *, struct file *,
216 unsigned, umode_t, int *);
217
218
219extern struct file_system_type nfs4_fs_type;
220
221
222struct rpc_clnt *nfs4_negotiate_security(struct rpc_clnt *, struct inode *, struct qstr *);
223struct vfsmount *nfs4_submount(struct nfs_server *, struct dentry *,
224 struct nfs_fh *, struct nfs_fattr *);
225int nfs4_replace_transport(struct nfs_server *server,
226 const struct nfs4_fs_locations *locations);
227
228
229extern int nfs4_call_sync(struct rpc_clnt *, struct nfs_server *,
230 struct rpc_message *, struct nfs4_sequence_args *,
231 struct nfs4_sequence_res *, int);
232extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, struct rpc_cred *, struct nfs4_setclientid_res *);
233extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct nfs4_setclientid_res *arg, struct rpc_cred *);
234extern int nfs4_proc_get_rootfh(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *, bool);
235extern int nfs4_proc_bind_conn_to_session(struct nfs_client *, struct rpc_cred *cred);
236extern int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred);
237extern int nfs4_destroy_clientid(struct nfs_client *clp);
238extern int nfs4_init_clientid(struct nfs_client *, struct rpc_cred *);
239extern int nfs41_init_clientid(struct nfs_client *, struct rpc_cred *);
240extern int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait);
241extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);
242extern int nfs4_proc_fs_locations(struct rpc_clnt *, struct inode *, const struct qstr *,
243 struct nfs4_fs_locations *, struct page *);
244extern int nfs4_proc_get_locations(struct inode *, struct nfs4_fs_locations *,
245 struct page *page, struct rpc_cred *);
246extern int nfs4_proc_fsid_present(struct inode *, struct rpc_cred *);
247extern struct rpc_clnt *nfs4_proc_lookup_mountpoint(struct inode *, struct qstr *,
248 struct nfs_fh *, struct nfs_fattr *);
249extern int nfs4_proc_secinfo(struct inode *, const struct qstr *, struct nfs4_secinfo_flavors *);
250extern const struct xattr_handler *nfs4_xattr_handlers[];
251extern int nfs4_set_rw_stateid(nfs4_stateid *stateid,
252 const struct nfs_open_context *ctx,
253 const struct nfs_lock_context *l_ctx,
254 fmode_t fmode);
255
256#if defined(CONFIG_NFS_V4_1)
257static inline struct nfs4_session *nfs4_get_session(const struct nfs_server *server)
258{
259 return server->nfs_client->cl_session;
260}
261
262extern int nfs41_setup_sequence(struct nfs4_session *session,
263 struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
264 struct rpc_task *task);
265extern int nfs41_sequence_done(struct rpc_task *, struct nfs4_sequence_res *);
266extern int nfs4_proc_create_session(struct nfs_client *, struct rpc_cred *);
267extern int nfs4_proc_destroy_session(struct nfs4_session *, struct rpc_cred *);
268extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
269 struct nfs_fsinfo *fsinfo);
270extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data,
271 bool sync);
272
273static inline bool
274is_ds_only_client(struct nfs_client *clp)
275{
276 return (clp->cl_exchange_flags & EXCHGID4_FLAG_MASK_PNFS) ==
277 EXCHGID4_FLAG_USE_PNFS_DS;
278}
279
280static inline bool
281is_ds_client(struct nfs_client *clp)
282{
283 return clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_DS;
284}
285
286static inline bool
287_nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
288 struct rpc_clnt **clntp, struct rpc_message *msg)
289{
290 struct rpc_cred *newcred = NULL;
291 rpc_authflavor_t flavor;
292
293 if (test_bit(sp4_mode, &clp->cl_sp4_flags)) {
294 spin_lock(&clp->cl_lock);
295 if (clp->cl_machine_cred != NULL)
296
297
298 newcred = clp->cl_machine_cred;
299 spin_unlock(&clp->cl_lock);
300 msg->rpc_cred = newcred;
301
302 flavor = clp->cl_rpcclient->cl_auth->au_flavor;
303 WARN_ON_ONCE(flavor != RPC_AUTH_GSS_KRB5I &&
304 flavor != RPC_AUTH_GSS_KRB5P);
305 *clntp = clp->cl_rpcclient;
306
307 return true;
308 }
309 return false;
310}
311
312
313
314
315
316
317
318static inline void
319nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
320 struct rpc_clnt **clntp, struct rpc_message *msg)
321{
322 _nfs4_state_protect(clp, sp4_mode, clntp, msg);
323}
324
325
326
327
328
329
330static inline void
331nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
332 struct rpc_message *msg, struct nfs_pgio_header *hdr)
333{
334 if (_nfs4_state_protect(clp, NFS_SP4_MACH_CRED_WRITE, clntp, msg) &&
335 !test_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags))
336 hdr->args.stable = NFS_FILE_SYNC;
337}
338#else
339static inline struct nfs4_session *nfs4_get_session(const struct nfs_server *server)
340{
341 return NULL;
342}
343
344static inline bool
345is_ds_only_client(struct nfs_client *clp)
346{
347 return false;
348}
349
350static inline bool
351is_ds_client(struct nfs_client *clp)
352{
353 return false;
354}
355
356static inline void
357nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_flags,
358 struct rpc_clnt **clntp, struct rpc_message *msg)
359{
360}
361
362static inline void
363nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
364 struct rpc_message *msg, struct nfs_pgio_header *hdr)
365{
366}
367#endif
368
369extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
370
371extern const u32 nfs4_fattr_bitmap[3];
372extern const u32 nfs4_statfs_bitmap[3];
373extern const u32 nfs4_pathconf_bitmap[3];
374extern const u32 nfs4_fsinfo_bitmap[3];
375extern const u32 nfs4_fs_locations_bitmap[3];
376
377void nfs40_shutdown_client(struct nfs_client *);
378void nfs41_shutdown_client(struct nfs_client *);
379int nfs40_init_client(struct nfs_client *);
380int nfs41_init_client(struct nfs_client *);
381void nfs4_free_client(struct nfs_client *);
382
383struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *);
384
385
386extern void nfs4_schedule_state_renewal(struct nfs_client *);
387extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
388extern void nfs4_kill_renewd(struct nfs_client *);
389extern void nfs4_renew_state(struct work_struct *);
390
391
392struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp);
393struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp);
394struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp);
395int nfs4_discover_server_trunking(struct nfs_client *clp,
396 struct nfs_client **);
397int nfs40_discover_server_trunking(struct nfs_client *clp,
398 struct nfs_client **, struct rpc_cred *);
399#if defined(CONFIG_NFS_V4_1)
400int nfs41_discover_server_trunking(struct nfs_client *clp,
401 struct nfs_client **, struct rpc_cred *);
402extern void nfs4_schedule_session_recovery(struct nfs4_session *, int);
403extern void nfs41_server_notify_target_slotid_update(struct nfs_client *clp);
404extern void nfs41_server_notify_highest_slotid_update(struct nfs_client *clp);
405
406#else
407static inline void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
408{
409}
410#endif
411
412extern struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *, gfp_t);
413extern void nfs4_put_state_owner(struct nfs4_state_owner *);
414extern void nfs4_purge_state_owners(struct nfs_server *);
415extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
416extern void nfs4_put_open_state(struct nfs4_state *);
417extern void nfs4_close_state(struct nfs4_state *, fmode_t);
418extern void nfs4_close_sync(struct nfs4_state *, fmode_t);
419extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
420extern void nfs_inode_find_state_and_recover(struct inode *inode,
421 const nfs4_stateid *stateid);
422extern int nfs4_state_mark_reclaim_nograce(struct nfs_client *, struct nfs4_state *);
423extern void nfs4_schedule_lease_recovery(struct nfs_client *);
424extern int nfs4_wait_clnt_recover(struct nfs_client *clp);
425extern int nfs4_client_recover_expired_lease(struct nfs_client *clp);
426extern void nfs4_schedule_state_manager(struct nfs_client *);
427extern void nfs4_schedule_path_down_recovery(struct nfs_client *clp);
428extern int nfs4_schedule_stateid_recovery(const struct nfs_server *, struct nfs4_state *);
429extern int nfs4_schedule_migration_recovery(const struct nfs_server *);
430extern void nfs4_schedule_lease_moved_recovery(struct nfs_client *);
431extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags);
432extern void nfs41_handle_server_scope(struct nfs_client *,
433 struct nfs41_server_scope **);
434extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
435extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
436extern int nfs4_select_rw_stateid(nfs4_stateid *, struct nfs4_state *,
437 fmode_t, const struct nfs_lockowner *);
438
439extern struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask);
440extern int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task);
441extern void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid);
442extern void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid);
443extern void nfs_release_seqid(struct nfs_seqid *seqid);
444extern void nfs_free_seqid(struct nfs_seqid *seqid);
445
446extern void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp);
447
448extern const nfs4_stateid zero_stateid;
449
450
451struct nfs_mount_info;
452extern struct nfs_subversion nfs_v4;
453struct dentry *nfs4_try_mount(int, const char *, struct nfs_mount_info *, struct nfs_subversion *);
454extern bool nfs4_disable_idmapping;
455extern unsigned short max_session_slots;
456extern unsigned short send_implementation_id;
457extern bool recover_lost_locks;
458
459#define NFS4_CLIENT_ID_UNIQ_LEN (64)
460extern char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN];
461
462
463#ifdef CONFIG_SYSCTL
464int nfs4_register_sysctl(void);
465void nfs4_unregister_sysctl(void);
466#else
467static inline int nfs4_register_sysctl(void)
468{
469 return 0;
470}
471
472static inline void nfs4_unregister_sysctl(void)
473{
474}
475#endif
476
477
478extern struct rpc_procinfo nfs4_procedures[];
479
480struct nfs4_mount_data;
481
482
483extern struct svc_version nfs4_callback_version1;
484extern struct svc_version nfs4_callback_version4;
485
486static inline void nfs4_stateid_copy(nfs4_stateid *dst, const nfs4_stateid *src)
487{
488 memcpy(dst, src, sizeof(*dst));
489}
490
491static inline bool nfs4_stateid_match(const nfs4_stateid *dst, const nfs4_stateid *src)
492{
493 return memcmp(dst, src, sizeof(*dst)) == 0;
494}
495
496static inline bool nfs4_stateid_match_other(const nfs4_stateid *dst, const nfs4_stateid *src)
497{
498 return memcmp(dst->other, src->other, NFS4_STATEID_OTHER_SIZE) == 0;
499}
500
501static inline bool nfs4_stateid_is_newer(const nfs4_stateid *s1, const nfs4_stateid *s2)
502{
503 return (s32)(be32_to_cpu(s1->seqid) - be32_to_cpu(s2->seqid)) > 0;
504}
505
506static inline bool nfs4_valid_open_stateid(const struct nfs4_state *state)
507{
508 return test_bit(NFS_STATE_RECOVERY_FAILED, &state->flags) == 0;
509}
510
511#else
512
513#define nfs4_close_state(a, b) do { } while (0)
514#define nfs4_close_sync(a, b) do { } while (0)
515#define nfs4_state_protect(a, b, c, d) do { } while (0)
516#define nfs4_state_protect_write(a, b, c, d) do { } while (0)
517
518#endif
519#endif
520