Branch data Line data Source code
1 : : /*
2 : : * linux/fs/nfs/nfs4_fs.h
3 : : *
4 : : * Copyright (C) 2005 Trond Myklebust
5 : : *
6 : : * NFSv4-specific filesystem definitions and declarations
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 : :
26 : : struct idmap;
27 : :
28 : : enum 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 : :
47 : : struct 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 : : int (*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
67 : : struct nfs_seqid_counter {
68 : : ktime_t create_time;
69 : : int owner_id;
70 : : int flags;
71 : : u32 counter;
72 : : spinlock_t lock; /* Protects the list */
73 : : struct list_head list; /* Defines sequence of RPC calls */
74 : : struct rpc_wait_queue wait; /* RPC call delay queue */
75 : : };
76 : :
77 : : struct nfs_seqid {
78 : : struct nfs_seqid_counter *sequence;
79 : : struct list_head list;
80 : : struct rpc_task *task;
81 : : };
82 : :
83 : : static inline void nfs_confirm_seqid(struct nfs_seqid_counter *seqid, int status)
84 : : {
85 : : if (seqid_mutating_err(-status))
86 : 0 : seqid->flags |= NFS_SEQID_CONFIRMED;
87 : : }
88 : :
89 : : /*
90 : : * NFS4 state_owners and lock_owners are simply labels for ordered
91 : : * sequences of RPC calls. Their sole purpose is to provide once-only
92 : : * semantics by allowing the server to identify replayed requests.
93 : : */
94 : : struct 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; /* Associated 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 : :
111 : : enum {
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 : : * struct nfs4_state maintains the client-side state for a given
122 : : * (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
123 : : *
124 : : * OPEN:
125 : : * In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
126 : : * we need to know how many files are open for reading or writing on a
127 : : * given inode. This information too is stored here.
128 : : *
129 : : * LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
130 : : */
131 : :
132 : : struct nfs4_lock_owner {
133 : : unsigned int lo_type;
134 : : #define NFS4_ANY_LOCK_TYPE (0U)
135 : : #define NFS4_FLOCK_LOCK_TYPE (1U << 0)
136 : : #define NFS4_POSIX_LOCK_TYPE (1U << 1)
137 : : union {
138 : : fl_owner_t posix_owner;
139 : : pid_t flock_owner;
140 : : } lo_u;
141 : : };
142 : :
143 : : struct nfs4_lock_state {
144 : : struct list_head ls_locks; /* Other lock stateids */
145 : : struct nfs4_state * ls_state; /* Pointer to open state */
146 : : #define NFS_LOCK_INITIALIZED 0
147 : : #define NFS_LOCK_LOST 1
148 : : unsigned long ls_flags;
149 : : struct nfs_seqid_counter ls_seqid;
150 : : nfs4_stateid ls_stateid;
151 : : atomic_t ls_count;
152 : : struct nfs4_lock_owner ls_owner;
153 : : };
154 : :
155 : : /* bits for nfs4_state->flags */
156 : : enum {
157 : : LK_STATE_IN_USE,
158 : : NFS_DELEGATED_STATE, /* Current stateid is delegation */
159 : : NFS_OPEN_STATE, /* OPEN stateid is set */
160 : : NFS_O_RDONLY_STATE, /* OPEN stateid has read-only state */
161 : : NFS_O_WRONLY_STATE, /* OPEN stateid has write-only state */
162 : : NFS_O_RDWR_STATE, /* OPEN stateid has read/write state */
163 : : NFS_STATE_RECLAIM_REBOOT, /* OPEN stateid server rebooted */
164 : : NFS_STATE_RECLAIM_NOGRACE, /* OPEN stateid needs to recover state */
165 : : NFS_STATE_POSIX_LOCKS, /* Posix locks are supported */
166 : : NFS_STATE_RECOVERY_FAILED, /* OPEN stateid state recovery failed */
167 : : };
168 : :
169 : : struct nfs4_state {
170 : : struct list_head open_states; /* List of states for the same state_owner */
171 : : struct list_head inode_states; /* List of states for the same inode */
172 : : struct list_head lock_states; /* List of subservient lock stateids */
173 : :
174 : : struct nfs4_state_owner *owner; /* Pointer to the open owner */
175 : : struct inode *inode; /* Pointer to the inode */
176 : :
177 : : unsigned long flags; /* Do we hold any locks? */
178 : : spinlock_t state_lock; /* Protects the lock_states list */
179 : :
180 : : seqlock_t seqlock; /* Protects the stateid/open_stateid */
181 : : nfs4_stateid stateid; /* Current stateid: may be delegation */
182 : : nfs4_stateid open_stateid; /* OPEN stateid */
183 : :
184 : : /* The following 3 fields are protected by owner->so_lock */
185 : : unsigned int n_rdonly; /* Number of read-only references */
186 : : unsigned int n_wronly; /* Number of write-only references */
187 : : unsigned int n_rdwr; /* Number of read/write references */
188 : : fmode_t state; /* State on the server (R,W, or RW) */
189 : : atomic_t count;
190 : : };
191 : :
192 : :
193 : : struct nfs4_exception {
194 : : long timeout;
195 : : int retry;
196 : : struct nfs4_state *state;
197 : : struct inode *inode;
198 : : };
199 : :
200 : : struct nfs4_state_recovery_ops {
201 : : int owner_flag_bit;
202 : : int state_flag_bit;
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 **,
208 : : struct rpc_cred *);
209 : : };
210 : :
211 : : struct nfs4_state_maintenance_ops {
212 : : int (*sched_state_renewal)(struct nfs_client *, struct rpc_cred *, unsigned);
213 : : struct rpc_cred * (*get_state_renewal_cred_locked)(struct nfs_client *);
214 : : int (*renew_lease)(struct nfs_client *, struct rpc_cred *);
215 : : };
216 : :
217 : : struct nfs4_mig_recovery_ops {
218 : : int (*get_locations)(struct inode *, struct nfs4_fs_locations *,
219 : : struct page *, struct rpc_cred *);
220 : : int (*fsid_present)(struct inode *, struct rpc_cred *);
221 : : };
222 : :
223 : : extern const struct dentry_operations nfs4_dentry_operations;
224 : :
225 : : /* dir.c */
226 : : int nfs_atomic_open(struct inode *, struct dentry *, struct file *,
227 : : unsigned, umode_t, int *);
228 : :
229 : : /* super.c */
230 : : extern struct file_system_type nfs4_fs_type;
231 : :
232 : : /* nfs4namespace.c */
233 : : struct rpc_clnt *nfs4_create_sec_client(struct rpc_clnt *, struct inode *, struct qstr *);
234 : : struct vfsmount *nfs4_submount(struct nfs_server *, struct dentry *,
235 : : struct nfs_fh *, struct nfs_fattr *);
236 : : int nfs4_replace_transport(struct nfs_server *server,
237 : : const struct nfs4_fs_locations *locations);
238 : :
239 : : /* nfs4proc.c */
240 : : extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, struct rpc_cred *, struct nfs4_setclientid_res *);
241 : : extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct nfs4_setclientid_res *arg, struct rpc_cred *);
242 : : extern int nfs4_proc_get_rootfh(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *, bool);
243 : : extern int nfs4_proc_bind_conn_to_session(struct nfs_client *, struct rpc_cred *cred);
244 : : extern int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred);
245 : : extern int nfs4_destroy_clientid(struct nfs_client *clp);
246 : : extern int nfs4_init_clientid(struct nfs_client *, struct rpc_cred *);
247 : : extern int nfs41_init_clientid(struct nfs_client *, struct rpc_cred *);
248 : : extern int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait);
249 : : extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);
250 : : extern int nfs4_proc_fs_locations(struct rpc_clnt *, struct inode *, const struct qstr *,
251 : : struct nfs4_fs_locations *, struct page *);
252 : : extern int nfs4_proc_get_locations(struct inode *, struct nfs4_fs_locations *,
253 : : struct page *page, struct rpc_cred *);
254 : : extern int nfs4_proc_fsid_present(struct inode *, struct rpc_cred *);
255 : : extern struct rpc_clnt *nfs4_proc_lookup_mountpoint(struct inode *, struct qstr *,
256 : : struct nfs_fh *, struct nfs_fattr *);
257 : : extern int nfs4_proc_secinfo(struct inode *, const struct qstr *, struct nfs4_secinfo_flavors *);
258 : : extern const struct xattr_handler *nfs4_xattr_handlers[];
259 : : extern int nfs4_set_rw_stateid(nfs4_stateid *stateid,
260 : : const struct nfs_open_context *ctx,
261 : : const struct nfs_lock_context *l_ctx,
262 : : fmode_t fmode);
263 : :
264 : : #if defined(CONFIG_NFS_V4_1)
265 : : static inline struct nfs4_session *nfs4_get_session(const struct nfs_server *server)
266 : : {
267 : : return server->nfs_client->cl_session;
268 : : }
269 : :
270 : : extern int nfs41_setup_sequence(struct nfs4_session *session,
271 : : struct nfs4_sequence_args *args, struct nfs4_sequence_res *res,
272 : : struct rpc_task *task);
273 : : extern int nfs4_proc_create_session(struct nfs_client *, struct rpc_cred *);
274 : : extern int nfs4_proc_destroy_session(struct nfs4_session *, struct rpc_cred *);
275 : : extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
276 : : struct nfs_fsinfo *fsinfo);
277 : : extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data,
278 : : bool sync);
279 : :
280 : : static inline bool
281 : : is_ds_only_client(struct nfs_client *clp)
282 : : {
283 : : return (clp->cl_exchange_flags & EXCHGID4_FLAG_MASK_PNFS) ==
284 : : EXCHGID4_FLAG_USE_PNFS_DS;
285 : : }
286 : :
287 : : static inline bool
288 : : is_ds_client(struct nfs_client *clp)
289 : : {
290 : : return clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_DS;
291 : : }
292 : :
293 : : static inline bool
294 : : _nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
295 : : struct rpc_clnt **clntp, struct rpc_message *msg)
296 : : {
297 : : struct rpc_cred *newcred = NULL;
298 : : rpc_authflavor_t flavor;
299 : :
300 : : if (test_bit(sp4_mode, &clp->cl_sp4_flags)) {
301 : : spin_lock(&clp->cl_lock);
302 : : if (clp->cl_machine_cred != NULL)
303 : : /* don't call get_rpccred on the machine cred -
304 : : * a reference will be held for life of clp */
305 : : newcred = clp->cl_machine_cred;
306 : : spin_unlock(&clp->cl_lock);
307 : : msg->rpc_cred = newcred;
308 : :
309 : : flavor = clp->cl_rpcclient->cl_auth->au_flavor;
310 : : WARN_ON_ONCE(flavor != RPC_AUTH_GSS_KRB5I &&
311 : : flavor != RPC_AUTH_GSS_KRB5P);
312 : : *clntp = clp->cl_rpcclient;
313 : :
314 : : return true;
315 : : }
316 : : return false;
317 : : }
318 : :
319 : : /*
320 : : * Function responsible for determining if an rpc_message should use the
321 : : * machine cred under SP4_MACH_CRED and if so switching the credential and
322 : : * authflavor (using the nfs_client's rpc_clnt which will be krb5i/p).
323 : : * Should be called before rpc_call_sync/rpc_call_async.
324 : : */
325 : : static inline void
326 : : nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
327 : : struct rpc_clnt **clntp, struct rpc_message *msg)
328 : : {
329 : : _nfs4_state_protect(clp, sp4_mode, clntp, msg);
330 : : }
331 : :
332 : : /*
333 : : * Special wrapper to nfs4_state_protect for write.
334 : : * If WRITE can use machine cred but COMMIT cannot, make sure all writes
335 : : * that use machine cred use NFS_FILE_SYNC.
336 : : */
337 : : static inline void
338 : : nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
339 : : struct rpc_message *msg, struct nfs_write_data *wdata)
340 : : {
341 : : if (_nfs4_state_protect(clp, NFS_SP4_MACH_CRED_WRITE, clntp, msg) &&
342 : : !test_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags))
343 : : wdata->args.stable = NFS_FILE_SYNC;
344 : : }
345 : : #else /* CONFIG_NFS_v4_1 */
346 : : static inline struct nfs4_session *nfs4_get_session(const struct nfs_server *server)
347 : : {
348 : : return NULL;
349 : : }
350 : :
351 : : static inline bool
352 : : is_ds_only_client(struct nfs_client *clp)
353 : : {
354 : : return false;
355 : : }
356 : :
357 : : static inline bool
358 : : is_ds_client(struct nfs_client *clp)
359 : : {
360 : : return false;
361 : : }
362 : :
363 : : static inline void
364 : : nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_flags,
365 : : struct rpc_clnt **clntp, struct rpc_message *msg)
366 : : {
367 : : }
368 : :
369 : : static inline void
370 : : nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
371 : : struct rpc_message *msg, struct nfs_write_data *wdata)
372 : : {
373 : : }
374 : : #endif /* CONFIG_NFS_V4_1 */
375 : :
376 : : extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
377 : :
378 : : extern const u32 nfs4_fattr_bitmap[3];
379 : : extern const u32 nfs4_statfs_bitmap[3];
380 : : extern const u32 nfs4_pathconf_bitmap[3];
381 : : extern const u32 nfs4_fsinfo_bitmap[3];
382 : : extern const u32 nfs4_fs_locations_bitmap[3];
383 : :
384 : : void nfs40_shutdown_client(struct nfs_client *);
385 : : void nfs41_shutdown_client(struct nfs_client *);
386 : : int nfs40_init_client(struct nfs_client *);
387 : : int nfs41_init_client(struct nfs_client *);
388 : : void nfs4_free_client(struct nfs_client *);
389 : :
390 : : struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *);
391 : :
392 : : /* nfs4renewd.c */
393 : : extern void nfs4_schedule_state_renewal(struct nfs_client *);
394 : : extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
395 : : extern void nfs4_kill_renewd(struct nfs_client *);
396 : : extern void nfs4_renew_state(struct work_struct *);
397 : :
398 : : /* nfs4state.c */
399 : : struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp);
400 : : struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp);
401 : : struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp);
402 : : int nfs4_discover_server_trunking(struct nfs_client *clp,
403 : : struct nfs_client **);
404 : : int nfs40_discover_server_trunking(struct nfs_client *clp,
405 : : struct nfs_client **, struct rpc_cred *);
406 : : #if defined(CONFIG_NFS_V4_1)
407 : : int nfs41_discover_server_trunking(struct nfs_client *clp,
408 : : struct nfs_client **, struct rpc_cred *);
409 : : extern void nfs4_schedule_session_recovery(struct nfs4_session *, int);
410 : : extern void nfs41_server_notify_target_slotid_update(struct nfs_client *clp);
411 : : extern void nfs41_server_notify_highest_slotid_update(struct nfs_client *clp);
412 : :
413 : : #else
414 : : static inline void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
415 : : {
416 : : }
417 : : #endif /* CONFIG_NFS_V4_1 */
418 : :
419 : : extern struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *, gfp_t);
420 : : extern void nfs4_put_state_owner(struct nfs4_state_owner *);
421 : : extern void nfs4_purge_state_owners(struct nfs_server *);
422 : : extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
423 : : extern void nfs4_put_open_state(struct nfs4_state *);
424 : : extern void nfs4_close_state(struct nfs4_state *, fmode_t);
425 : : extern void nfs4_close_sync(struct nfs4_state *, fmode_t);
426 : : extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
427 : : extern void nfs_inode_find_state_and_recover(struct inode *inode,
428 : : const nfs4_stateid *stateid);
429 : : extern void nfs4_schedule_lease_recovery(struct nfs_client *);
430 : : extern int nfs4_wait_clnt_recover(struct nfs_client *clp);
431 : : extern int nfs4_client_recover_expired_lease(struct nfs_client *clp);
432 : : extern void nfs4_schedule_state_manager(struct nfs_client *);
433 : : extern void nfs4_schedule_path_down_recovery(struct nfs_client *clp);
434 : : extern int nfs4_schedule_stateid_recovery(const struct nfs_server *, struct nfs4_state *);
435 : : extern int nfs4_schedule_migration_recovery(const struct nfs_server *);
436 : : extern void nfs4_schedule_lease_moved_recovery(struct nfs_client *);
437 : : extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags);
438 : : extern void nfs41_handle_server_scope(struct nfs_client *,
439 : : struct nfs41_server_scope **);
440 : : extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
441 : : extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
442 : : extern int nfs4_select_rw_stateid(nfs4_stateid *, struct nfs4_state *,
443 : : fmode_t, const struct nfs_lockowner *);
444 : :
445 : : extern struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask);
446 : : extern int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task);
447 : : extern void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid);
448 : : extern void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid);
449 : : extern void nfs_release_seqid(struct nfs_seqid *seqid);
450 : : extern void nfs_free_seqid(struct nfs_seqid *seqid);
451 : :
452 : : extern void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp);
453 : :
454 : : extern const nfs4_stateid zero_stateid;
455 : :
456 : : /* nfs4super.c */
457 : : struct nfs_mount_info;
458 : : extern struct nfs_subversion nfs_v4;
459 : : struct dentry *nfs4_try_mount(int, const char *, struct nfs_mount_info *, struct nfs_subversion *);
460 : : extern bool nfs4_disable_idmapping;
461 : : extern unsigned short max_session_slots;
462 : : extern unsigned short send_implementation_id;
463 : : extern bool recover_lost_locks;
464 : :
465 : : #define NFS4_CLIENT_ID_UNIQ_LEN (64)
466 : : extern char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN];
467 : :
468 : : /* nfs4sysctl.c */
469 : : #ifdef CONFIG_SYSCTL
470 : : int nfs4_register_sysctl(void);
471 : : void nfs4_unregister_sysctl(void);
472 : : #else
473 : : static inline int nfs4_register_sysctl(void)
474 : : {
475 : : return 0;
476 : : }
477 : :
478 : : static inline void nfs4_unregister_sysctl(void)
479 : : {
480 : : }
481 : : #endif
482 : :
483 : : /* nfs4xdr.c */
484 : : extern struct rpc_procinfo nfs4_procedures[];
485 : :
486 : : struct nfs4_mount_data;
487 : :
488 : : /* callback_xdr.c */
489 : : extern struct svc_version nfs4_callback_version1;
490 : : extern struct svc_version nfs4_callback_version4;
491 : :
492 : : static inline void nfs4_stateid_copy(nfs4_stateid *dst, const nfs4_stateid *src)
493 : : {
494 : 0 : memcpy(dst, src, sizeof(*dst));
495 : : }
496 : :
497 : : static inline bool nfs4_stateid_match(const nfs4_stateid *dst, const nfs4_stateid *src)
498 : : {
499 : 0 : return memcmp(dst, src, sizeof(*dst)) == 0;
500 : : }
501 : :
502 : : static inline bool nfs4_valid_open_stateid(const struct nfs4_state *state)
503 : : {
504 : : return test_bit(NFS_STATE_RECOVERY_FAILED, &state->flags) == 0;
505 : : }
506 : :
507 : : #else
508 : :
509 : : #define nfs4_close_state(a, b) do { } while (0)
510 : : #define nfs4_close_sync(a, b) do { } while (0)
511 : : #define nfs4_state_protect(a, b, c, d) do { } while (0)
512 : : #define nfs4_state_protect_write(a, b, c, d) do { } while (0)
513 : :
514 : : #endif /* CONFIG_NFS_V4 */
515 : : #endif /* __LINUX_FS_NFS_NFS4_FS.H */
|
