2 * Copyright (c) 2001 The Regents of the University of Michigan.
5 * Kendrick Smith <kmsmith@umich.edu>
6 * Andy Adamson <andros@umich.edu>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
22 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 #ifndef _NFSD4_STATE_H
36 #define _NFSD4_STATE_H
38 #include <linux/idr.h>
39 #include <linux/sunrpc/svc_xprt.h>
54 stateid_opaque_t si_opaque
;
57 #define STATEID_FMT "(%08x/%08x/%08x/%08x)"
58 #define STATEID_VAL(s) \
59 (s)->si_opaque.so_clid.cl_boot, \
60 (s)->si_opaque.so_clid.cl_id, \
61 (s)->si_opaque.so_id, \
64 struct nfsd4_callback
{
65 struct nfs4_client
*cb_clp
;
66 struct list_head cb_per_client
;
68 struct rpc_message cb_msg
;
69 struct nfsd4_callback_ops
*cb_ops
;
70 struct work_struct cb_work
;
74 struct nfsd4_callback_ops
{
75 void (*prepare
)(struct nfsd4_callback
*);
76 int (*done
)(struct nfsd4_callback
*, struct rpc_task
*);
77 void (*release
)(struct nfsd4_callback
*);
81 * A core object that represents a "common" stateid. These are generally
82 * embedded within the different (more specific) stateid objects and contain
83 * fields that are of general use to any stateid.
87 #define NFS4_OPEN_STID 1
88 #define NFS4_LOCK_STID 2
89 #define NFS4_DELEG_STID 4
90 /* For an open stateid kept around *only* to process close replays: */
91 #define NFS4_CLOSED_STID 8
92 /* For a deleg stateid kept around only to process free_stateid's: */
93 #define NFS4_REVOKED_DELEG_STID 16
94 #define NFS4_CLOSED_DELEG_STID 32
95 #define NFS4_LAYOUT_STID 64
96 unsigned char sc_type
;
98 struct nfs4_client
*sc_client
;
99 struct nfs4_file
*sc_file
;
100 void (*sc_free
)(struct nfs4_stid
*);
104 * Represents a delegation stateid. The nfs4_client holds references to these
105 * and they are put when it is being destroyed or when the delegation is
106 * returned by the client:
108 * o 1 reference as long as a delegation is still in force (taken when it's
109 * alloc'd, put when it's returned or revoked)
111 * o 1 reference as long as a recall rpc is in progress (taken when the lease
112 * is broken, put when the rpc exits)
114 * o 1 more ephemeral reference for each nfsd thread currently doing something
115 * with that delegation without holding the cl_lock
117 * If the server attempts to recall a delegation and the client doesn't do so
118 * before a timeout, the server may also revoke the delegation. In that case,
119 * the object will either be destroyed (v4.0) or moved to a per-client list of
120 * revoked delegations (v4.1+).
122 * This object is a superset of the nfs4_stid.
124 struct nfs4_delegation
{
125 struct nfs4_stid dl_stid
; /* must be first field */
126 struct list_head dl_perfile
;
127 struct list_head dl_perclnt
;
128 struct list_head dl_recall_lru
; /* delegation recalled */
133 struct nfsd4_callback dl_recall
;
136 #define cb_to_delegation(cb) \
137 container_of(cb, struct nfs4_delegation, dl_recall)
139 /* client delegation callback info */
140 struct nfs4_cb_conn
{
141 /* SETCLIENTID info */
142 struct sockaddr_storage cb_addr
;
143 struct sockaddr_storage cb_saddr
;
145 u32 cb_prog
; /* used only in 4.0 case;
146 per-session otherwise */
147 u32 cb_ident
; /* minorversion 0 only */
148 struct svc_xprt
*cb_xprt
; /* minorversion 1 only */
151 static inline struct nfs4_delegation
*delegstateid(struct nfs4_stid
*s
)
153 return container_of(s
, struct nfs4_delegation
, dl_stid
);
156 /* Maximum number of slots per session. 160 is useful for long haul TCP */
157 #define NFSD_MAX_SLOTS_PER_SESSION 160
158 /* Maximum number of operations per session compound */
159 #define NFSD_MAX_OPS_PER_COMPOUND 16
160 /* Maximum session per slot cache size */
161 #define NFSD_SLOT_CACHE_SIZE 2048
162 /* Maximum number of NFSD_SLOT_CACHE_SIZE slots per session */
163 #define NFSD_CACHE_SIZE_SLOTS_PER_SESSION 32
164 #define NFSD_MAX_MEM_PER_SESSION \
165 (NFSD_CACHE_SIZE_SLOTS_PER_SESSION * NFSD_SLOT_CACHE_SIZE)
172 #define NFSD4_SLOT_INUSE (1 << 0)
173 #define NFSD4_SLOT_CACHETHIS (1 << 1)
174 #define NFSD4_SLOT_INITIALIZED (1 << 2)
179 struct nfsd4_channel_attrs
{
190 struct nfsd4_cb_sec
{
191 u32 flavor
; /* (u32)(-1) used to mean "no valid flavor" */
196 struct nfsd4_create_session
{
198 struct nfs4_sessionid sessionid
;
201 struct nfsd4_channel_attrs fore_channel
;
202 struct nfsd4_channel_attrs back_channel
;
204 struct nfsd4_cb_sec cb_sec
;
207 struct nfsd4_backchannel_ctl
{
209 struct nfsd4_cb_sec bc_cb_sec
;
212 struct nfsd4_bind_conn_to_session
{
213 struct nfs4_sessionid sessionid
;
217 /* The single slot clientid cache structure */
218 struct nfsd4_clid_slot
{
221 struct nfsd4_create_session sl_cr_ses
;
225 struct list_head cn_persession
;
226 struct svc_xprt
*cn_xprt
;
227 struct svc_xpt_user cn_xpt_user
;
228 struct nfsd4_session
*cn_session
;
229 /* CDFC4_FORE, CDFC4_BACK: */
230 unsigned char cn_flags
;
234 * Representation of a v4.1+ session. These are refcounted in a similar fashion
235 * to the nfs4_client. References are only taken when the server is actively
236 * working on the object (primarily during the processing of compounds).
238 struct nfsd4_session
{
240 struct list_head se_hash
; /* hash by sessionid */
241 struct list_head se_perclnt
;
242 /* See SESSION4_PERSIST, etc. for standard flags; this is internal-only: */
243 #define NFS4_SESSION_DEAD 0x010
245 struct nfs4_client
*se_client
;
246 struct nfs4_sessionid se_sessionid
;
247 struct nfsd4_channel_attrs se_fchannel
;
248 struct nfsd4_channel_attrs se_bchannel
;
249 struct nfsd4_cb_sec se_cb_sec
;
250 struct list_head se_conns
;
253 struct nfsd4_slot
*se_slots
[]; /* forward channel slots */
256 /* formatted contents of nfs4_sessionid */
257 struct nfsd4_sessionid
{
263 #define HEXDIR_LEN 33 /* hex version of 16 byte md5 of cl_name plus '\0' */
266 * struct nfs4_client - one per client. Clientids live here.
268 * The initial object created by an NFS client using SETCLIENTID (for NFSv4.0)
269 * or EXCHANGE_ID (for NFSv4.1+). These objects are refcounted and timestamped.
270 * Each nfsd_net_ns object contains a set of these and they are tracked via
271 * short and long form clientid. They are hashed and searched for under the
272 * per-nfsd_net client_lock spinlock.
274 * References to it are only held during the processing of compounds, and in
275 * certain other operations. In their "resting state" they have a refcount of
276 * 0. If they are not renewed within a lease period, they become eligible for
277 * destruction by the laundromat.
279 * These objects can also be destroyed prematurely by the fault injection code,
280 * or if the client sends certain forms of SETCLIENTID or EXCHANGE_ID updates.
281 * Care is taken *not* to do this however when the objects have an elevated
284 * o Each nfs4_client is hashed by clientid
286 * o Each nfs4_clients is also hashed by name (the opaque quantity initially
287 * sent by the client to identify itself).
289 * o cl_perclient list is used to ensure no dangling stateowner references
290 * when we expire the nfs4_client
293 struct list_head cl_idhash
; /* hash by cl_clientid.id */
294 struct rb_node cl_namenode
; /* link into by-name trees */
295 struct list_head
*cl_ownerstr_hashtbl
;
296 struct list_head cl_openowners
;
297 struct idr cl_stateids
; /* stateid lookup */
298 struct list_head cl_delegations
;
299 struct list_head cl_revoked
; /* unacknowledged, revoked 4.1 state */
300 struct list_head cl_lru
; /* tail queue */
301 #ifdef CONFIG_NFSD_PNFS
302 struct list_head cl_lo_states
; /* outstanding layout states */
304 struct xdr_netobj cl_name
; /* id generated by client */
305 nfs4_verifier cl_verifier
; /* generated by client */
306 time_t cl_time
; /* time of last lease renewal */
307 struct sockaddr_storage cl_addr
; /* client ipaddress */
308 bool cl_mach_cred
; /* SP4_MACH_CRED in force */
309 struct svc_cred cl_cred
; /* setclientid principal */
310 clientid_t cl_clientid
; /* generated by server */
311 nfs4_verifier cl_confirm
; /* generated by server */
314 /* for v4.0 and v4.1 callbacks: */
315 struct nfs4_cb_conn cl_cb_conn
;
316 #define NFSD4_CLIENT_CB_UPDATE (0)
317 #define NFSD4_CLIENT_CB_KILL (1)
318 #define NFSD4_CLIENT_STABLE (2) /* client on stable storage */
319 #define NFSD4_CLIENT_RECLAIM_COMPLETE (3) /* reclaim_complete done */
320 #define NFSD4_CLIENT_CONFIRMED (4) /* client is confirmed */
321 #define NFSD4_CLIENT_UPCALL_LOCK (5) /* upcall serialization */
322 #define NFSD4_CLIENT_CB_FLAG_MASK (1 << NFSD4_CLIENT_CB_UPDATE | \
323 1 << NFSD4_CLIENT_CB_KILL)
324 unsigned long cl_flags
;
325 struct rpc_cred
*cl_cb_cred
;
326 struct rpc_clnt
*cl_cb_client
;
328 #define NFSD4_CB_UP 0
329 #define NFSD4_CB_UNKNOWN 1
330 #define NFSD4_CB_DOWN 2
331 #define NFSD4_CB_FAULT 3
333 struct nfsd4_callback cl_cb_null
;
334 struct nfsd4_session
*cl_cb_session
;
335 struct list_head cl_callbacks
; /* list of in-progress callbacks */
337 /* for all client information that callback code might need: */
341 struct list_head cl_sessions
;
342 struct nfsd4_clid_slot cl_cs_slot
; /* create_session slot */
343 u32 cl_exchange_flags
;
344 /* number of rpc's in progress over an associated session: */
345 atomic_t cl_refcount
;
347 /* for nfs41 callbacks */
348 /* We currently support a single back channel with a single slot */
349 unsigned long cl_cb_slot_busy
;
350 struct rpc_wait_queue cl_cb_waitq
; /* backchannel callers may */
351 /* wait here for slots */
355 /* struct nfs4_client_reset
356 * one per old client. Populates reset_str_hashtbl. Filled from conf_id_hashtbl
357 * upon lease reset, or from upcall to state_daemon (to read in state
358 * from non-volitile storage) upon reboot.
360 struct nfs4_client_reclaim
{
361 struct list_head cr_strhash
; /* hash by cr_name */
362 struct nfs4_client
*cr_clp
; /* pointer to associated clp */
363 char cr_recdir
[HEXDIR_LEN
]; /* recover dir */
367 update_stateid(stateid_t
*stateid
)
369 stateid
->si_generation
++;
370 /* Wraparound recommendation from 3530bis-13 9.1.3.2: */
371 if (stateid
->si_generation
== 0)
372 stateid
->si_generation
= 1;
375 /* A reasonable value for REPLAY_ISIZE was estimated as follows:
376 * The OPEN response, typically the largest, requires
377 * 4(status) + 8(stateid) + 20(changeinfo) + 4(rflags) + 8(verifier) +
378 * 4(deleg. type) + 8(deleg. stateid) + 4(deleg. recall flag) +
379 * 20(deleg. space limit) + ~32(deleg. ace) = 112 bytes
382 #define NFSD4_REPLAY_ISIZE 112
385 * Replay buffer, where the result of the last seqid-mutating operation
390 unsigned int rp_buflen
;
392 struct knfsd_fh rp_openfh
;
393 struct mutex rp_mutex
;
394 char rp_ibuf
[NFSD4_REPLAY_ISIZE
];
397 struct nfs4_stateowner
;
399 struct nfs4_stateowner_operations
{
400 void (*so_unhash
)(struct nfs4_stateowner
*);
401 void (*so_free
)(struct nfs4_stateowner
*);
405 * A core object that represents either an open or lock owner. The object and
406 * lock owner objects have one of these embedded within them. Refcounts and
407 * other fields common to both owner types are contained within these
410 struct nfs4_stateowner
{
411 struct list_head so_strhash
;
412 struct list_head so_stateids
;
413 struct nfs4_client
*so_client
;
414 const struct nfs4_stateowner_operations
*so_ops
;
415 /* after increment in nfsd4_bump_seqid, represents the next
416 * sequence id expected from the client: */
419 struct xdr_netobj so_owner
; /* open owner name */
420 struct nfs4_replay so_replay
;
421 bool so_is_open_owner
;
425 * When a file is opened, the client provides an open state owner opaque string
426 * that indicates the "owner" of that open. These objects are refcounted.
427 * References to it are held by each open state associated with it. This object
428 * is a superset of the nfs4_stateowner struct.
430 struct nfs4_openowner
{
431 struct nfs4_stateowner oo_owner
; /* must be first field */
432 struct list_head oo_perclient
;
434 * We keep around openowners a little while after last close,
435 * which saves clients from having to confirm, and allows us to
436 * handle close replays if they come soon enough. The close_lru
437 * is a list of such openowners, to be reaped by the laundromat
438 * thread eventually if they remain unused:
440 struct list_head oo_close_lru
;
441 struct nfs4_ol_stateid
*oo_last_closed_stid
;
442 time_t oo_time
; /* time of placement on so_close_lru */
443 #define NFS4_OO_CONFIRMED 1
444 unsigned char oo_flags
;
448 * Represents a generic "lockowner". Similar to an openowner. References to it
449 * are held by the lock stateids that are created on its behalf. This object is
450 * a superset of the nfs4_stateowner struct (or would be if it needed any extra
453 struct nfs4_lockowner
{
454 struct nfs4_stateowner lo_owner
; /* must be first element */
457 static inline struct nfs4_openowner
* openowner(struct nfs4_stateowner
*so
)
459 return container_of(so
, struct nfs4_openowner
, oo_owner
);
462 static inline struct nfs4_lockowner
* lockowner(struct nfs4_stateowner
*so
)
464 return container_of(so
, struct nfs4_lockowner
, lo_owner
);
468 * nfs4_file: a file opened by some number of (open) nfs4_stateowners.
470 * These objects are global. nfsd keeps one instance of a nfs4_file per
471 * filehandle (though it may keep multiple file descriptors for each). Each
472 * inode can have multiple filehandles associated with it, so there is
473 * (potentially) a many to one relationship between this struct and struct
476 * These are hashed by filehandle in the file_hashtbl, which is protected by
477 * the global state_lock spinlock.
482 struct hlist_node fi_hash
; /* hash on fi_fhandle */
483 struct list_head fi_stateids
;
485 struct list_head fi_delegations
;
486 struct rcu_head fi_rcu
;
488 /* One each for O_RDONLY, O_WRONLY, O_RDWR: */
489 struct file
* fi_fds
[3];
491 * Each open or lock stateid contributes 0-4 to the counts
492 * below depending on which bits are set in st_access_bitmap:
493 * 1 to fi_access[O_RDONLY] if NFS4_SHARE_ACCES_READ is set
494 * + 1 to fi_access[O_WRONLY] if NFS4_SHARE_ACCESS_WRITE is set
495 * + 1 to both of the above if NFS4_SHARE_ACCESS_BOTH is set.
497 atomic_t fi_access
[2];
499 struct file
*fi_deleg_file
;
501 struct knfsd_fh fi_fhandle
;
502 bool fi_had_conflict
;
503 #ifdef CONFIG_NFSD_PNFS
504 struct list_head fi_lo_states
;
505 atomic_t fi_lo_recalls
;
510 * A generic struct representing either a open or lock stateid. The nfs4_client
511 * holds a reference to each of these objects, and they in turn hold a
512 * reference to their respective stateowners. The client's reference is
513 * released in response to a close or unlock (depending on whether it's an open
514 * or lock stateid) or when the client is being destroyed.
516 * In the case of v4.0 open stateids, these objects are preserved for a little
517 * while after close in order to handle CLOSE replays. Those are eventually
518 * reclaimed via a LRU scheme by the laundromat.
520 * This object is a superset of the nfs4_stid. "ol" stands for "Open or Lock".
521 * Better suggestions welcome.
523 struct nfs4_ol_stateid
{
524 struct nfs4_stid st_stid
; /* must be first field */
525 struct list_head st_perfile
;
526 struct list_head st_perstateowner
;
527 struct list_head st_locks
;
528 struct nfs4_stateowner
* st_stateowner
;
529 unsigned char st_access_bmap
;
530 unsigned char st_deny_bmap
;
531 struct nfs4_ol_stateid
* st_openstp
;
534 static inline struct nfs4_ol_stateid
*openlockstateid(struct nfs4_stid
*s
)
536 return container_of(s
, struct nfs4_ol_stateid
, st_stid
);
539 struct nfs4_layout_stateid
{
540 struct nfs4_stid ls_stid
;
541 struct list_head ls_perclnt
;
542 struct list_head ls_perfile
;
544 struct list_head ls_layouts
;
546 struct file
*ls_file
;
547 struct nfsd4_callback ls_recall
;
548 stateid_t ls_recall_sid
;
552 static inline struct nfs4_layout_stateid
*layoutstateid(struct nfs4_stid
*s
)
554 return container_of(s
, struct nfs4_layout_stateid
, ls_stid
);
557 /* flags for preprocess_seqid_op() */
558 #define RD_STATE 0x00000010
559 #define WR_STATE 0x00000020
562 NFSPROC4_CLNT_CB_NULL
= 0,
563 NFSPROC4_CLNT_CB_RECALL
,
564 NFSPROC4_CLNT_CB_LAYOUT
,
565 NFSPROC4_CLNT_CB_SEQUENCE
,
569 struct nfsd4_compound_state
;
572 extern __be32
nfs4_preprocess_stateid_op(struct net
*net
,
573 struct nfsd4_compound_state
*cstate
,
574 stateid_t
*stateid
, int flags
, struct file
**filp
);
575 __be32
nfsd4_lookup_stateid(struct nfsd4_compound_state
*cstate
,
576 stateid_t
*stateid
, unsigned char typemask
,
577 struct nfs4_stid
**s
, struct nfsd_net
*nn
);
578 struct nfs4_stid
*nfs4_alloc_stid(struct nfs4_client
*cl
,
579 struct kmem_cache
*slab
);
580 void nfs4_unhash_stid(struct nfs4_stid
*s
);
581 void nfs4_put_stid(struct nfs4_stid
*s
);
582 void nfs4_remove_reclaim_record(struct nfs4_client_reclaim
*, struct nfsd_net
*);
583 extern void nfs4_release_reclaim(struct nfsd_net
*);
584 extern struct nfs4_client_reclaim
*nfsd4_find_reclaim_client(const char *recdir
,
585 struct nfsd_net
*nn
);
586 extern __be32
nfs4_check_open_reclaim(clientid_t
*clid
,
587 struct nfsd4_compound_state
*cstate
, struct nfsd_net
*nn
);
588 extern int set_callback_cred(void);
589 extern void nfsd4_probe_callback(struct nfs4_client
*clp
);
590 extern void nfsd4_probe_callback_sync(struct nfs4_client
*clp
);
591 extern void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*);
592 extern void nfsd4_init_cb(struct nfsd4_callback
*cb
, struct nfs4_client
*clp
,
593 struct nfsd4_callback_ops
*ops
, enum nfsd4_cb_op op
);
594 extern void nfsd4_run_cb(struct nfsd4_callback
*cb
);
595 extern int nfsd4_create_callback_queue(void);
596 extern void nfsd4_destroy_callback_queue(void);
597 extern void nfsd4_shutdown_callback(struct nfs4_client
*);
598 extern void nfsd4_prepare_cb_recall(struct nfs4_delegation
*dp
);
599 extern struct nfs4_client_reclaim
*nfs4_client_to_reclaim(const char *name
,
600 struct nfsd_net
*nn
);
601 extern bool nfs4_has_reclaimed_state(const char *name
, struct nfsd_net
*nn
);
603 struct nfs4_file
*find_file(struct knfsd_fh
*fh
);
604 void put_nfs4_file(struct nfs4_file
*fi
);
605 static inline void get_nfs4_file(struct nfs4_file
*fi
)
607 atomic_inc(&fi
->fi_ref
);
609 struct file
*find_any_file(struct nfs4_file
*f
);
611 /* grace period management */
612 void nfsd4_end_grace(struct nfsd_net
*nn
);
614 /* nfs4recover operations */
615 extern int nfsd4_client_tracking_init(struct net
*net
);
616 extern void nfsd4_client_tracking_exit(struct net
*net
);
617 extern void nfsd4_client_record_create(struct nfs4_client
*clp
);
618 extern void nfsd4_client_record_remove(struct nfs4_client
*clp
);
619 extern int nfsd4_client_record_check(struct nfs4_client
*clp
);
620 extern void nfsd4_record_grace_done(struct nfsd_net
*nn
);
622 /* nfs fault injection functions */
623 #ifdef CONFIG_NFSD_FAULT_INJECTION
624 int nfsd_fault_inject_init(void);
625 void nfsd_fault_inject_cleanup(void);
627 u64
nfsd_inject_print_clients(void);
628 u64
nfsd_inject_forget_client(struct sockaddr_storage
*, size_t);
629 u64
nfsd_inject_forget_clients(u64
);
631 u64
nfsd_inject_print_locks(void);
632 u64
nfsd_inject_forget_client_locks(struct sockaddr_storage
*, size_t);
633 u64
nfsd_inject_forget_locks(u64
);
635 u64
nfsd_inject_print_openowners(void);
636 u64
nfsd_inject_forget_client_openowners(struct sockaddr_storage
*, size_t);
637 u64
nfsd_inject_forget_openowners(u64
);
639 u64
nfsd_inject_print_delegations(void);
640 u64
nfsd_inject_forget_client_delegations(struct sockaddr_storage
*, size_t);
641 u64
nfsd_inject_forget_delegations(u64
);
642 u64
nfsd_inject_recall_client_delegations(struct sockaddr_storage
*, size_t);
643 u64
nfsd_inject_recall_delegations(u64
);
644 #else /* CONFIG_NFSD_FAULT_INJECTION */
645 static inline int nfsd_fault_inject_init(void) { return 0; }
646 static inline void nfsd_fault_inject_cleanup(void) {}
647 #endif /* CONFIG_NFSD_FAULT_INJECTION */
649 #endif /* NFSD4_STATE_H */