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
;
67 struct rpc_message cb_msg
;
68 struct nfsd4_callback_ops
*cb_ops
;
69 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 */
129 struct nfs4_clnt_odstate
*dl_clnt_odstate
;
134 struct nfsd4_callback dl_recall
;
137 #define cb_to_delegation(cb) \
138 container_of(cb, struct nfs4_delegation, dl_recall)
140 /* client delegation callback info */
141 struct nfs4_cb_conn
{
142 /* SETCLIENTID info */
143 struct sockaddr_storage cb_addr
;
144 struct sockaddr_storage cb_saddr
;
146 u32 cb_prog
; /* used only in 4.0 case;
147 per-session otherwise */
148 u32 cb_ident
; /* minorversion 0 only */
149 struct svc_xprt
*cb_xprt
; /* minorversion 1 only */
152 static inline struct nfs4_delegation
*delegstateid(struct nfs4_stid
*s
)
154 return container_of(s
, struct nfs4_delegation
, dl_stid
);
157 /* Maximum number of slots per session. 160 is useful for long haul TCP */
158 #define NFSD_MAX_SLOTS_PER_SESSION 160
159 /* Maximum number of operations per session compound */
160 #define NFSD_MAX_OPS_PER_COMPOUND 16
161 /* Maximum session per slot cache size */
162 #define NFSD_SLOT_CACHE_SIZE 2048
163 /* Maximum number of NFSD_SLOT_CACHE_SIZE slots per session */
164 #define NFSD_CACHE_SIZE_SLOTS_PER_SESSION 32
165 #define NFSD_MAX_MEM_PER_SESSION \
166 (NFSD_CACHE_SIZE_SLOTS_PER_SESSION * NFSD_SLOT_CACHE_SIZE)
173 #define NFSD4_SLOT_INUSE (1 << 0)
174 #define NFSD4_SLOT_CACHETHIS (1 << 1)
175 #define NFSD4_SLOT_INITIALIZED (1 << 2)
180 struct nfsd4_channel_attrs
{
191 struct nfsd4_cb_sec
{
192 u32 flavor
; /* (u32)(-1) used to mean "no valid flavor" */
197 struct nfsd4_create_session
{
199 struct nfs4_sessionid sessionid
;
202 struct nfsd4_channel_attrs fore_channel
;
203 struct nfsd4_channel_attrs back_channel
;
205 struct nfsd4_cb_sec cb_sec
;
208 struct nfsd4_backchannel_ctl
{
210 struct nfsd4_cb_sec bc_cb_sec
;
213 struct nfsd4_bind_conn_to_session
{
214 struct nfs4_sessionid sessionid
;
218 /* The single slot clientid cache structure */
219 struct nfsd4_clid_slot
{
222 struct nfsd4_create_session sl_cr_ses
;
226 struct list_head cn_persession
;
227 struct svc_xprt
*cn_xprt
;
228 struct svc_xpt_user cn_xpt_user
;
229 struct nfsd4_session
*cn_session
;
230 /* CDFC4_FORE, CDFC4_BACK: */
231 unsigned char cn_flags
;
235 * Representation of a v4.1+ session. These are refcounted in a similar fashion
236 * to the nfs4_client. References are only taken when the server is actively
237 * working on the object (primarily during the processing of compounds).
239 struct nfsd4_session
{
241 struct list_head se_hash
; /* hash by sessionid */
242 struct list_head se_perclnt
;
243 /* See SESSION4_PERSIST, etc. for standard flags; this is internal-only: */
244 #define NFS4_SESSION_DEAD 0x010
246 struct nfs4_client
*se_client
;
247 struct nfs4_sessionid se_sessionid
;
248 struct nfsd4_channel_attrs se_fchannel
;
249 struct nfsd4_channel_attrs se_bchannel
;
250 struct nfsd4_cb_sec se_cb_sec
;
251 struct list_head se_conns
;
254 struct nfsd4_slot
*se_slots
[]; /* forward channel slots */
257 /* formatted contents of nfs4_sessionid */
258 struct nfsd4_sessionid
{
264 #define HEXDIR_LEN 33 /* hex version of 16 byte md5 of cl_name plus '\0' */
267 * struct nfs4_client - one per client. Clientids live here.
269 * The initial object created by an NFS client using SETCLIENTID (for NFSv4.0)
270 * or EXCHANGE_ID (for NFSv4.1+). These objects are refcounted and timestamped.
271 * Each nfsd_net_ns object contains a set of these and they are tracked via
272 * short and long form clientid. They are hashed and searched for under the
273 * per-nfsd_net client_lock spinlock.
275 * References to it are only held during the processing of compounds, and in
276 * certain other operations. In their "resting state" they have a refcount of
277 * 0. If they are not renewed within a lease period, they become eligible for
278 * destruction by the laundromat.
280 * These objects can also be destroyed prematurely by the fault injection code,
281 * or if the client sends certain forms of SETCLIENTID or EXCHANGE_ID updates.
282 * Care is taken *not* to do this however when the objects have an elevated
285 * o Each nfs4_client is hashed by clientid
287 * o Each nfs4_clients is also hashed by name (the opaque quantity initially
288 * sent by the client to identify itself).
290 * o cl_perclient list is used to ensure no dangling stateowner references
291 * when we expire the nfs4_client
294 struct list_head cl_idhash
; /* hash by cl_clientid.id */
295 struct rb_node cl_namenode
; /* link into by-name trees */
296 struct list_head
*cl_ownerstr_hashtbl
;
297 struct list_head cl_openowners
;
298 struct idr cl_stateids
; /* stateid lookup */
299 struct list_head cl_delegations
;
300 struct list_head cl_revoked
; /* unacknowledged, revoked 4.1 state */
301 struct list_head cl_lru
; /* tail queue */
302 #ifdef CONFIG_NFSD_PNFS
303 struct list_head cl_lo_states
; /* outstanding layout states */
305 struct xdr_netobj cl_name
; /* id generated by client */
306 nfs4_verifier cl_verifier
; /* generated by client */
307 time_t cl_time
; /* time of last lease renewal */
308 struct sockaddr_storage cl_addr
; /* client ipaddress */
309 bool cl_mach_cred
; /* SP4_MACH_CRED in force */
310 struct svc_cred cl_cred
; /* setclientid principal */
311 clientid_t cl_clientid
; /* generated by server */
312 nfs4_verifier cl_confirm
; /* generated by server */
315 /* for v4.0 and v4.1 callbacks: */
316 struct nfs4_cb_conn cl_cb_conn
;
317 #define NFSD4_CLIENT_CB_UPDATE (0)
318 #define NFSD4_CLIENT_CB_KILL (1)
319 #define NFSD4_CLIENT_STABLE (2) /* client on stable storage */
320 #define NFSD4_CLIENT_RECLAIM_COMPLETE (3) /* reclaim_complete done */
321 #define NFSD4_CLIENT_CONFIRMED (4) /* client is confirmed */
322 #define NFSD4_CLIENT_UPCALL_LOCK (5) /* upcall serialization */
323 #define NFSD4_CLIENT_CB_FLAG_MASK (1 << NFSD4_CLIENT_CB_UPDATE | \
324 1 << NFSD4_CLIENT_CB_KILL)
325 unsigned long cl_flags
;
326 struct rpc_cred
*cl_cb_cred
;
327 struct rpc_clnt
*cl_cb_client
;
329 #define NFSD4_CB_UP 0
330 #define NFSD4_CB_UNKNOWN 1
331 #define NFSD4_CB_DOWN 2
332 #define NFSD4_CB_FAULT 3
334 struct nfsd4_callback cl_cb_null
;
335 struct nfsd4_session
*cl_cb_session
;
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 * Per-client state indicating no. of opens and outstanding delegations
469 * on a file from a particular client.'od' stands for 'open & delegation'
471 struct nfs4_clnt_odstate
{
472 struct nfs4_client
*co_client
;
473 struct nfs4_file
*co_file
;
474 struct list_head co_perfile
;
479 * nfs4_file: a file opened by some number of (open) nfs4_stateowners.
481 * These objects are global. nfsd keeps one instance of a nfs4_file per
482 * filehandle (though it may keep multiple file descriptors for each). Each
483 * inode can have multiple filehandles associated with it, so there is
484 * (potentially) a many to one relationship between this struct and struct
487 * These are hashed by filehandle in the file_hashtbl, which is protected by
488 * the global state_lock spinlock.
493 struct hlist_node fi_hash
; /* hash on fi_fhandle */
494 struct list_head fi_stateids
;
496 struct list_head fi_delegations
;
497 struct rcu_head fi_rcu
;
499 struct list_head fi_clnt_odstate
;
500 /* One each for O_RDONLY, O_WRONLY, O_RDWR: */
501 struct file
* fi_fds
[3];
503 * Each open or lock stateid contributes 0-4 to the counts
504 * below depending on which bits are set in st_access_bitmap:
505 * 1 to fi_access[O_RDONLY] if NFS4_SHARE_ACCES_READ is set
506 * + 1 to fi_access[O_WRONLY] if NFS4_SHARE_ACCESS_WRITE is set
507 * + 1 to both of the above if NFS4_SHARE_ACCESS_BOTH is set.
509 atomic_t fi_access
[2];
511 struct file
*fi_deleg_file
;
513 struct knfsd_fh fi_fhandle
;
514 bool fi_had_conflict
;
515 #ifdef CONFIG_NFSD_PNFS
516 struct list_head fi_lo_states
;
517 atomic_t fi_lo_recalls
;
522 * A generic struct representing either a open or lock stateid. The nfs4_client
523 * holds a reference to each of these objects, and they in turn hold a
524 * reference to their respective stateowners. The client's reference is
525 * released in response to a close or unlock (depending on whether it's an open
526 * or lock stateid) or when the client is being destroyed.
528 * In the case of v4.0 open stateids, these objects are preserved for a little
529 * while after close in order to handle CLOSE replays. Those are eventually
530 * reclaimed via a LRU scheme by the laundromat.
532 * This object is a superset of the nfs4_stid. "ol" stands for "Open or Lock".
533 * Better suggestions welcome.
535 struct nfs4_ol_stateid
{
536 struct nfs4_stid st_stid
; /* must be first field */
537 struct list_head st_perfile
;
538 struct list_head st_perstateowner
;
539 struct list_head st_locks
;
540 struct nfs4_stateowner
* st_stateowner
;
541 struct nfs4_clnt_odstate
* st_clnt_odstate
;
542 unsigned char st_access_bmap
;
543 unsigned char st_deny_bmap
;
544 struct nfs4_ol_stateid
* st_openstp
;
547 static inline struct nfs4_ol_stateid
*openlockstateid(struct nfs4_stid
*s
)
549 return container_of(s
, struct nfs4_ol_stateid
, st_stid
);
552 struct nfs4_layout_stateid
{
553 struct nfs4_stid ls_stid
;
554 struct list_head ls_perclnt
;
555 struct list_head ls_perfile
;
557 struct list_head ls_layouts
;
559 struct file
*ls_file
;
560 struct nfsd4_callback ls_recall
;
561 stateid_t ls_recall_sid
;
565 static inline struct nfs4_layout_stateid
*layoutstateid(struct nfs4_stid
*s
)
567 return container_of(s
, struct nfs4_layout_stateid
, ls_stid
);
570 /* flags for preprocess_seqid_op() */
571 #define RD_STATE 0x00000010
572 #define WR_STATE 0x00000020
575 NFSPROC4_CLNT_CB_NULL
= 0,
576 NFSPROC4_CLNT_CB_RECALL
,
577 NFSPROC4_CLNT_CB_LAYOUT
,
578 NFSPROC4_CLNT_CB_SEQUENCE
,
582 struct nfsd4_compound_state
;
585 extern __be32
nfs4_preprocess_stateid_op(struct net
*net
,
586 struct nfsd4_compound_state
*cstate
,
587 stateid_t
*stateid
, int flags
, struct file
**filp
);
588 __be32
nfsd4_lookup_stateid(struct nfsd4_compound_state
*cstate
,
589 stateid_t
*stateid
, unsigned char typemask
,
590 struct nfs4_stid
**s
, struct nfsd_net
*nn
);
591 struct nfs4_stid
*nfs4_alloc_stid(struct nfs4_client
*cl
,
592 struct kmem_cache
*slab
);
593 void nfs4_unhash_stid(struct nfs4_stid
*s
);
594 void nfs4_put_stid(struct nfs4_stid
*s
);
595 void nfs4_remove_reclaim_record(struct nfs4_client_reclaim
*, struct nfsd_net
*);
596 extern void nfs4_release_reclaim(struct nfsd_net
*);
597 extern struct nfs4_client_reclaim
*nfsd4_find_reclaim_client(const char *recdir
,
598 struct nfsd_net
*nn
);
599 extern __be32
nfs4_check_open_reclaim(clientid_t
*clid
,
600 struct nfsd4_compound_state
*cstate
, struct nfsd_net
*nn
);
601 extern int set_callback_cred(void);
602 extern void nfsd4_probe_callback(struct nfs4_client
*clp
);
603 extern void nfsd4_probe_callback_sync(struct nfs4_client
*clp
);
604 extern void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*);
605 extern void nfsd4_init_cb(struct nfsd4_callback
*cb
, struct nfs4_client
*clp
,
606 struct nfsd4_callback_ops
*ops
, enum nfsd4_cb_op op
);
607 extern void nfsd4_run_cb(struct nfsd4_callback
*cb
);
608 extern int nfsd4_create_callback_queue(void);
609 extern void nfsd4_destroy_callback_queue(void);
610 extern void nfsd4_shutdown_callback(struct nfs4_client
*);
611 extern void nfsd4_prepare_cb_recall(struct nfs4_delegation
*dp
);
612 extern struct nfs4_client_reclaim
*nfs4_client_to_reclaim(const char *name
,
613 struct nfsd_net
*nn
);
614 extern bool nfs4_has_reclaimed_state(const char *name
, struct nfsd_net
*nn
);
616 struct nfs4_file
*find_file(struct knfsd_fh
*fh
);
617 void put_nfs4_file(struct nfs4_file
*fi
);
618 static inline void get_nfs4_file(struct nfs4_file
*fi
)
620 atomic_inc(&fi
->fi_ref
);
622 struct file
*find_any_file(struct nfs4_file
*f
);
624 /* grace period management */
625 void nfsd4_end_grace(struct nfsd_net
*nn
);
627 /* nfs4recover operations */
628 extern int nfsd4_client_tracking_init(struct net
*net
);
629 extern void nfsd4_client_tracking_exit(struct net
*net
);
630 extern void nfsd4_client_record_create(struct nfs4_client
*clp
);
631 extern void nfsd4_client_record_remove(struct nfs4_client
*clp
);
632 extern int nfsd4_client_record_check(struct nfs4_client
*clp
);
633 extern void nfsd4_record_grace_done(struct nfsd_net
*nn
);
635 /* nfs fault injection functions */
636 #ifdef CONFIG_NFSD_FAULT_INJECTION
637 int nfsd_fault_inject_init(void);
638 void nfsd_fault_inject_cleanup(void);
640 u64
nfsd_inject_print_clients(void);
641 u64
nfsd_inject_forget_client(struct sockaddr_storage
*, size_t);
642 u64
nfsd_inject_forget_clients(u64
);
644 u64
nfsd_inject_print_locks(void);
645 u64
nfsd_inject_forget_client_locks(struct sockaddr_storage
*, size_t);
646 u64
nfsd_inject_forget_locks(u64
);
648 u64
nfsd_inject_print_openowners(void);
649 u64
nfsd_inject_forget_client_openowners(struct sockaddr_storage
*, size_t);
650 u64
nfsd_inject_forget_openowners(u64
);
652 u64
nfsd_inject_print_delegations(void);
653 u64
nfsd_inject_forget_client_delegations(struct sockaddr_storage
*, size_t);
654 u64
nfsd_inject_forget_delegations(u64
);
655 u64
nfsd_inject_recall_client_delegations(struct sockaddr_storage
*, size_t);
656 u64
nfsd_inject_recall_delegations(u64
);
657 #else /* CONFIG_NFSD_FAULT_INJECTION */
658 static inline int nfsd_fault_inject_init(void) { return 0; }
659 static inline void nfsd_fault_inject_cleanup(void) {}
660 #endif /* CONFIG_NFSD_FAULT_INJECTION */
662 #endif /* NFSD4_STATE_H */