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 nfs41_sequence_done(struct rpc_task *, struct nfs4_sequence_res *);
274 : : extern int nfs4_proc_create_session(struct nfs_client *, struct rpc_cred *);
275 : : extern int nfs4_proc_destroy_session(struct nfs4_session *, struct rpc_cred *);
276 : : extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
277 : : struct nfs_fsinfo *fsinfo);
278 : : extern int nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data,
279 : : bool sync);
280 : :
281 : : static inline bool
282 : : is_ds_only_client(struct nfs_client *clp)
283 : : {
284 : : return (clp->cl_exchange_flags & EXCHGID4_FLAG_MASK_PNFS) ==
285 : : EXCHGID4_FLAG_USE_PNFS_DS;
286 : : }
287 : :
288 : : static inline bool
289 : : is_ds_client(struct nfs_client *clp)
290 : : {
291 : : return clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_DS;
292 : : }
293 : :
294 : : static inline bool
295 : : _nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
296 : : struct rpc_clnt **clntp, struct rpc_message *msg)
297 : : {
298 : : struct rpc_cred *newcred = NULL;
299 : : rpc_authflavor_t flavor;
300 : :
301 : : if (test_bit(sp4_mode, &clp->cl_sp4_flags)) {
302 : : spin_lock(&clp->cl_lock);
303 : : if (clp->cl_machine_cred != NULL)
304 : : /* don't call get_rpccred on the machine cred -
305 : : * a reference will be held for life of clp */
306 : : newcred = clp->cl_machine_cred;
307 : : spin_unlock(&clp->cl_lock);
308 : : msg->rpc_cred = newcred;
309 : :
310 : : flavor = clp->cl_rpcclient->cl_auth->au_flavor;
311 : : WARN_ON_ONCE(flavor != RPC_AUTH_GSS_KRB5I &&
312 : : flavor != RPC_AUTH_GSS_KRB5P);
313 : : *clntp = clp->cl_rpcclient;
314 : :
315 : : return true;
316 : : }
317 : : return false;
318 : : }
319 : :
320 : : /*
321 : : * Function responsible for determining if an rpc_message should use the
322 : : * machine cred under SP4_MACH_CRED and if so switching the credential and
323 : : * authflavor (using the nfs_client's rpc_clnt which will be krb5i/p).
324 : : * Should be called before rpc_call_sync/rpc_call_async.
325 : : */
326 : : static inline void
327 : : nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_mode,
328 : : struct rpc_clnt **clntp, struct rpc_message *msg)
329 : : {
330 : : _nfs4_state_protect(clp, sp4_mode, clntp, msg);
331 : : }
332 : :
333 : : /*
334 : : * Special wrapper to nfs4_state_protect for write.
335 : : * If WRITE can use machine cred but COMMIT cannot, make sure all writes
336 : : * that use machine cred use NFS_FILE_SYNC.
337 : : */
338 : : static inline void
339 : : nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
340 : : struct rpc_message *msg, struct nfs_write_data *wdata)
341 : : {
342 : : if (_nfs4_state_protect(clp, NFS_SP4_MACH_CRED_WRITE, clntp, msg) &&
343 : : !test_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags))
344 : : wdata->args.stable = NFS_FILE_SYNC;
345 : : }
346 : : #else /* CONFIG_NFS_v4_1 */
347 : : static inline struct nfs4_session *nfs4_get_session(const struct nfs_server *server)
348 : : {
349 : : return NULL;
350 : : }
351 : :
352 : : static inline bool
353 : : is_ds_only_client(struct nfs_client *clp)
354 : : {
355 : : return false;
356 : : }
357 : :
358 : : static inline bool
359 : : is_ds_client(struct nfs_client *clp)
360 : : {
361 : : return false;
362 : : }
363 : :
364 : : static inline void
365 : : nfs4_state_protect(struct nfs_client *clp, unsigned long sp4_flags,
366 : : struct rpc_clnt **clntp, struct rpc_message *msg)
367 : : {
368 : : }
369 : :
370 : : static inline void
371 : : nfs4_state_protect_write(struct nfs_client *clp, struct rpc_clnt **clntp,
372 : : struct rpc_message *msg, struct nfs_write_data *wdata)
373 : : {
374 : : }
375 : : #endif /* CONFIG_NFS_V4_1 */
376 : :
377 : : extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
378 : :
379 : : extern const u32 nfs4_fattr_bitmap[3];
380 : : extern const u32 nfs4_statfs_bitmap[3];
381 : : extern const u32 nfs4_pathconf_bitmap[3];
382 : : extern const u32 nfs4_fsinfo_bitmap[3];
383 : : extern const u32 nfs4_fs_locations_bitmap[3];
384 : :
385 : : void nfs40_shutdown_client(struct nfs_client *);
386 : : void nfs41_shutdown_client(struct nfs_client *);
387 : : int nfs40_init_client(struct nfs_client *);
388 : : int nfs41_init_client(struct nfs_client *);
389 : : void nfs4_free_client(struct nfs_client *);
390 : :
391 : : struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *);
392 : :
393 : : /* nfs4renewd.c */
394 : : extern void nfs4_schedule_state_renewal(struct nfs_client *);
395 : : extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
396 : : extern void nfs4_kill_renewd(struct nfs_client *);
397 : : extern void nfs4_renew_state(struct work_struct *);
398 : :
399 : : /* nfs4state.c */
400 : : struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp);
401 : : struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp);
402 : : struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp);
403 : : int nfs4_discover_server_trunking(struct nfs_client *clp,
404 : : struct nfs_client **);
405 : : int nfs40_discover_server_trunking(struct nfs_client *clp,
406 : : struct nfs_client **, struct rpc_cred *);
407 : : #if defined(CONFIG_NFS_V4_1)
408 : : int nfs41_discover_server_trunking(struct nfs_client *clp,
409 : : struct nfs_client **, struct rpc_cred *);
410 : : extern void nfs4_schedule_session_recovery(struct nfs4_session *, int);
411 : : extern void nfs41_server_notify_target_slotid_update(struct nfs_client *clp);
412 : : extern void nfs41_server_notify_highest_slotid_update(struct nfs_client *clp);
413 : :
414 : : #else
415 : : static inline void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
416 : : {
417 : : }
418 : : #endif /* CONFIG_NFS_V4_1 */
419 : :
420 : : extern struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *, gfp_t);
421 : : extern void nfs4_put_state_owner(struct nfs4_state_owner *);
422 : : extern void nfs4_purge_state_owners(struct nfs_server *);
423 : : extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
424 : : extern void nfs4_put_open_state(struct nfs4_state *);
425 : : extern void nfs4_close_state(struct nfs4_state *, fmode_t);
426 : : extern void nfs4_close_sync(struct nfs4_state *, fmode_t);
427 : : extern void nfs4_state_set_mode_locked(struct nfs4_state *, fmode_t);
428 : : extern void nfs_inode_find_state_and_recover(struct inode *inode,
429 : : const nfs4_stateid *stateid);
430 : : extern void nfs4_schedule_lease_recovery(struct nfs_client *);
431 : : extern int nfs4_wait_clnt_recover(struct nfs_client *clp);
432 : : extern int nfs4_client_recover_expired_lease(struct nfs_client *clp);
433 : : extern void nfs4_schedule_state_manager(struct nfs_client *);
434 : : extern void nfs4_schedule_path_down_recovery(struct nfs_client *clp);
435 : : extern int nfs4_schedule_stateid_recovery(const struct nfs_server *, struct nfs4_state *);
436 : : extern int nfs4_schedule_migration_recovery(const struct nfs_server *);
437 : : extern void nfs4_schedule_lease_moved_recovery(struct nfs_client *);
438 : : extern void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags);
439 : : extern void nfs41_handle_server_scope(struct nfs_client *,
440 : : struct nfs41_server_scope **);
441 : : extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
442 : : extern int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl);
443 : : extern int nfs4_select_rw_stateid(nfs4_stateid *, struct nfs4_state *,
444 : : fmode_t, const struct nfs_lockowner *);
445 : :
446 : : extern struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask);
447 : : extern int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task);
448 : : extern void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid);
449 : : extern void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid);
450 : : extern void nfs_release_seqid(struct nfs_seqid *seqid);
451 : : extern void nfs_free_seqid(struct nfs_seqid *seqid);
452 : :
453 : : extern void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp);
454 : :
455 : : extern const nfs4_stateid zero_stateid;
456 : :
457 : : /* nfs4super.c */
458 : : struct nfs_mount_info;
459 : : extern struct nfs_subversion nfs_v4;
460 : : struct dentry *nfs4_try_mount(int, const char *, struct nfs_mount_info *, struct nfs_subversion *);
461 : : extern bool nfs4_disable_idmapping;
462 : : extern unsigned short max_session_slots;
463 : : extern unsigned short send_implementation_id;
464 : : extern bool recover_lost_locks;
465 : :
466 : : #define NFS4_CLIENT_ID_UNIQ_LEN (64)
467 : : extern char nfs4_client_id_uniquifier[NFS4_CLIENT_ID_UNIQ_LEN];
468 : :
469 : : /* nfs4sysctl.c */
470 : : #ifdef CONFIG_SYSCTL
471 : : int nfs4_register_sysctl(void);
472 : : void nfs4_unregister_sysctl(void);
473 : : #else
474 : : static inline int nfs4_register_sysctl(void)
475 : : {
476 : : return 0;
477 : : }
478 : :
479 : : static inline void nfs4_unregister_sysctl(void)
480 : : {
481 : : }
482 : : #endif
483 : :
484 : : /* nfs4xdr.c */
485 : : extern struct rpc_procinfo nfs4_procedures[];
486 : :
487 : : struct nfs4_mount_data;
488 : :
489 : : /* callback_xdr.c */
490 : : extern struct svc_version nfs4_callback_version1;
491 : : extern struct svc_version nfs4_callback_version4;
492 : :
493 : : static inline void nfs4_stateid_copy(nfs4_stateid *dst, const nfs4_stateid *src)
494 : : {
495 : 0 : memcpy(dst, src, sizeof(*dst));
496 : : }
497 : :
498 : : static inline bool nfs4_stateid_match(const nfs4_stateid *dst, const nfs4_stateid *src)
499 : : {
500 : 0 : return memcmp(dst, src, sizeof(*dst)) == 0;
501 : : }
502 : :
503 : : static inline bool nfs4_valid_open_stateid(const struct nfs4_state *state)
504 : : {
505 : : return test_bit(NFS_STATE_RECOVERY_FAILED, &state->flags) == 0;
506 : : }
507 : :
508 : : #else
509 : :
510 : : #define nfs4_close_state(a, b) do { } while (0)
511 : : #define nfs4_close_sync(a, b) do { } while (0)
512 : : #define nfs4_state_protect(a, b, c, d) do { } while (0)
513 : : #define nfs4_state_protect_write(a, b, c, d) do { } while (0)
514 : :
515 : : #endif /* CONFIG_NFS_V4 */
516 : : #endif /* __LINUX_FS_NFS_NFS4_FS.H */
|
