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.
34 #include <linux/nfs4.h>
35 #include <linux/sunrpc/clnt.h>
36 #include <linux/sunrpc/xprt.h>
37 #include <linux/sunrpc/svc_xprt.h>
38 #include <linux/slab.h>
46 #define NFSDDBG_FACILITY NFSDDBG_PROC
48 static void nfsd4_mark_cb_fault(struct nfs4_client
*clp
);
50 #define NFSPROC4_CB_NULL 0
51 #define NFSPROC4_CB_COMPOUND 1
53 /* Index of predefined Linux callback client operations */
55 struct nfs4_cb_compound_hdr
{
57 u32 ident
; /* minorversion 0 only */
65 static __be32
*xdr_encode_empty_array(__be32
*p
)
72 * Encode/decode NFSv4 CB basic data types
74 * Basic NFSv4 callback data types are defined in section 15 of RFC
75 * 3530: "Network File System (NFS) version 4 Protocol" and section
76 * 20 of RFC 5661: "Network File System (NFS) Version 4 Minor Version
80 static void encode_uint32(struct xdr_stream
*xdr
, u32 n
)
82 WARN_ON_ONCE(xdr_stream_encode_u32(xdr
, n
) < 0);
85 static void encode_bitmap4(struct xdr_stream
*xdr
, const __u32
*bitmap
,
88 xdr_stream_encode_uint32_array(xdr
, bitmap
, len
);
91 static int decode_cb_fattr4(struct xdr_stream
*xdr
, uint32_t *bitmap
,
92 struct nfs4_cb_fattr
*fattr
)
94 fattr
->ncf_cb_change
= 0;
95 fattr
->ncf_cb_fsize
= 0;
96 if (bitmap
[0] & FATTR4_WORD0_CHANGE
)
97 if (xdr_stream_decode_u64(xdr
, &fattr
->ncf_cb_change
) < 0)
98 return -NFSERR_BAD_XDR
;
99 if (bitmap
[0] & FATTR4_WORD0_SIZE
)
100 if (xdr_stream_decode_u64(xdr
, &fattr
->ncf_cb_fsize
) < 0)
101 return -NFSERR_BAD_XDR
;
105 static void encode_nfs_cb_opnum4(struct xdr_stream
*xdr
, enum nfs_cb_opnum4 op
)
109 p
= xdr_reserve_space(xdr
, 4);
110 *p
= cpu_to_be32(op
);
116 * typedef opaque nfs_fh4<NFS4_FHSIZE>;
118 static void encode_nfs_fh4(struct xdr_stream
*xdr
, const struct knfsd_fh
*fh
)
120 u32 length
= fh
->fh_size
;
123 BUG_ON(length
> NFS4_FHSIZE
);
124 p
= xdr_reserve_space(xdr
, 4 + length
);
125 xdr_encode_opaque(p
, &fh
->fh_raw
, length
);
136 static void encode_stateid4(struct xdr_stream
*xdr
, const stateid_t
*sid
)
140 p
= xdr_reserve_space(xdr
, NFS4_STATEID_SIZE
);
141 *p
++ = cpu_to_be32(sid
->si_generation
);
142 xdr_encode_opaque_fixed(p
, &sid
->si_opaque
, NFS4_STATEID_OTHER_SIZE
);
148 * typedef opaque sessionid4[NFS4_SESSIONID_SIZE];
150 static void encode_sessionid4(struct xdr_stream
*xdr
,
151 const struct nfsd4_session
*session
)
155 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
);
156 xdr_encode_opaque_fixed(p
, session
->se_sessionid
.data
,
157 NFS4_MAX_SESSIONID_LEN
);
163 static const struct {
166 } nfs_cb_errtbl
[] = {
168 { NFS4ERR_PERM
, -EPERM
},
169 { NFS4ERR_NOENT
, -ENOENT
},
170 { NFS4ERR_IO
, -EIO
},
171 { NFS4ERR_NXIO
, -ENXIO
},
172 { NFS4ERR_ACCESS
, -EACCES
},
173 { NFS4ERR_EXIST
, -EEXIST
},
174 { NFS4ERR_XDEV
, -EXDEV
},
175 { NFS4ERR_NOTDIR
, -ENOTDIR
},
176 { NFS4ERR_ISDIR
, -EISDIR
},
177 { NFS4ERR_INVAL
, -EINVAL
},
178 { NFS4ERR_FBIG
, -EFBIG
},
179 { NFS4ERR_NOSPC
, -ENOSPC
},
180 { NFS4ERR_ROFS
, -EROFS
},
181 { NFS4ERR_MLINK
, -EMLINK
},
182 { NFS4ERR_NAMETOOLONG
, -ENAMETOOLONG
},
183 { NFS4ERR_NOTEMPTY
, -ENOTEMPTY
},
184 { NFS4ERR_DQUOT
, -EDQUOT
},
185 { NFS4ERR_STALE
, -ESTALE
},
186 { NFS4ERR_BADHANDLE
, -EBADHANDLE
},
187 { NFS4ERR_BAD_COOKIE
, -EBADCOOKIE
},
188 { NFS4ERR_NOTSUPP
, -ENOTSUPP
},
189 { NFS4ERR_TOOSMALL
, -ETOOSMALL
},
190 { NFS4ERR_SERVERFAULT
, -ESERVERFAULT
},
191 { NFS4ERR_BADTYPE
, -EBADTYPE
},
192 { NFS4ERR_LOCKED
, -EAGAIN
},
193 { NFS4ERR_RESOURCE
, -EREMOTEIO
},
194 { NFS4ERR_SYMLINK
, -ELOOP
},
195 { NFS4ERR_OP_ILLEGAL
, -EOPNOTSUPP
},
196 { NFS4ERR_DEADLOCK
, -EDEADLK
},
201 * If we cannot translate the error, the recovery routines should
204 * Note: remaining NFSv4 error codes have values > 10000, so should
205 * not conflict with native Linux error codes.
207 static int nfs_cb_stat_to_errno(int status
)
211 for (i
= 0; nfs_cb_errtbl
[i
].stat
!= -1; i
++) {
212 if (nfs_cb_errtbl
[i
].stat
== status
)
213 return nfs_cb_errtbl
[i
].errno
;
216 dprintk("NFSD: Unrecognized NFS CB status value: %u\n", status
);
220 static int decode_cb_op_status(struct xdr_stream
*xdr
,
221 enum nfs_cb_opnum4 expected
, int *status
)
226 p
= xdr_inline_decode(xdr
, 4 + 4);
227 if (unlikely(p
== NULL
))
229 op
= be32_to_cpup(p
++);
230 if (unlikely(op
!= expected
))
232 *status
= nfs_cb_stat_to_errno(be32_to_cpup(p
));
237 dprintk("NFSD: Callback server returned operation %d but "
238 "we issued a request for %d\n", op
, expected
);
245 * struct CB_COMPOUND4args {
247 * uint32_t minorversion;
248 * uint32_t callback_ident;
249 * nfs_cb_argop4 argarray<>;
252 static void encode_cb_compound4args(struct xdr_stream
*xdr
,
253 struct nfs4_cb_compound_hdr
*hdr
)
257 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4);
258 p
= xdr_encode_empty_array(p
); /* empty tag */
259 *p
++ = cpu_to_be32(hdr
->minorversion
);
260 *p
++ = cpu_to_be32(hdr
->ident
);
263 *p
= cpu_to_be32(hdr
->nops
); /* argarray element count */
267 * Update argarray element count
269 static void encode_cb_nops(struct nfs4_cb_compound_hdr
*hdr
)
271 BUG_ON(hdr
->nops
> NFS4_MAX_BACK_CHANNEL_OPS
);
272 *hdr
->nops_p
= cpu_to_be32(hdr
->nops
);
278 * struct CB_COMPOUND4res {
281 * nfs_cb_resop4 resarray<>;
284 static int decode_cb_compound4res(struct xdr_stream
*xdr
,
285 struct nfs4_cb_compound_hdr
*hdr
)
290 p
= xdr_inline_decode(xdr
, 4 + 4);
291 if (unlikely(p
== NULL
))
293 hdr
->status
= be32_to_cpup(p
++);
295 length
= be32_to_cpup(p
++);
296 p
= xdr_inline_decode(xdr
, length
+ 4);
297 if (unlikely(p
== NULL
))
299 p
+= XDR_QUADLEN(length
);
300 hdr
->nops
= be32_to_cpup(p
);
309 * struct CB_RECALL4args {
315 static void encode_cb_recall4args(struct xdr_stream
*xdr
,
316 const struct nfs4_delegation
*dp
,
317 struct nfs4_cb_compound_hdr
*hdr
)
321 encode_nfs_cb_opnum4(xdr
, OP_CB_RECALL
);
322 encode_stateid4(xdr
, &dp
->dl_stid
.sc_stateid
);
324 p
= xdr_reserve_space(xdr
, 4);
325 *p
++ = xdr_zero
; /* truncate */
327 encode_nfs_fh4(xdr
, &dp
->dl_stid
.sc_file
->fi_fhandle
);
335 * struct CB_RECALLANY4args {
336 * uint32_t craa_objects_to_keep;
337 * bitmap4 craa_type_mask;
341 encode_cb_recallany4args(struct xdr_stream
*xdr
,
342 struct nfs4_cb_compound_hdr
*hdr
, struct nfsd4_cb_recall_any
*ra
)
344 encode_nfs_cb_opnum4(xdr
, OP_CB_RECALL_ANY
);
345 encode_uint32(xdr
, ra
->ra_keep
);
346 encode_bitmap4(xdr
, ra
->ra_bmval
, ARRAY_SIZE(ra
->ra_bmval
));
352 * struct CB_GETATTR4args {
354 * bitmap4 attr_request;
357 * The size and change attributes are the only one
358 * guaranteed to be serviced by the client.
361 encode_cb_getattr4args(struct xdr_stream
*xdr
, struct nfs4_cb_compound_hdr
*hdr
,
362 struct nfs4_cb_fattr
*fattr
)
364 struct nfs4_delegation
*dp
=
365 container_of(fattr
, struct nfs4_delegation
, dl_cb_fattr
);
366 struct knfsd_fh
*fh
= &dp
->dl_stid
.sc_file
->fi_fhandle
;
368 encode_nfs_cb_opnum4(xdr
, OP_CB_GETATTR
);
369 encode_nfs_fh4(xdr
, fh
);
370 encode_bitmap4(xdr
, fattr
->ncf_cb_bmap
, ARRAY_SIZE(fattr
->ncf_cb_bmap
));
377 * struct CB_SEQUENCE4args {
378 * sessionid4 csa_sessionid;
379 * sequenceid4 csa_sequenceid;
380 * slotid4 csa_slotid;
381 * slotid4 csa_highest_slotid;
382 * bool csa_cachethis;
383 * referring_call_list4 csa_referring_call_lists<>;
386 static void encode_cb_sequence4args(struct xdr_stream
*xdr
,
387 const struct nfsd4_callback
*cb
,
388 struct nfs4_cb_compound_hdr
*hdr
)
390 struct nfsd4_session
*session
= cb
->cb_clp
->cl_cb_session
;
393 if (hdr
->minorversion
== 0)
396 encode_nfs_cb_opnum4(xdr
, OP_CB_SEQUENCE
);
397 encode_sessionid4(xdr
, session
);
399 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4 + 4);
400 *p
++ = cpu_to_be32(session
->se_cb_seq_nr
); /* csa_sequenceid */
401 *p
++ = xdr_zero
; /* csa_slotid */
402 *p
++ = xdr_zero
; /* csa_highest_slotid */
403 *p
++ = xdr_zero
; /* csa_cachethis */
404 xdr_encode_empty_array(p
); /* csa_referring_call_lists */
412 * struct CB_SEQUENCE4resok {
413 * sessionid4 csr_sessionid;
414 * sequenceid4 csr_sequenceid;
415 * slotid4 csr_slotid;
416 * slotid4 csr_highest_slotid;
417 * slotid4 csr_target_highest_slotid;
420 * union CB_SEQUENCE4res switch (nfsstat4 csr_status) {
422 * CB_SEQUENCE4resok csr_resok4;
427 * Our current back channel implmentation supports a single backchannel
428 * with a single slot.
430 static int decode_cb_sequence4resok(struct xdr_stream
*xdr
,
431 struct nfsd4_callback
*cb
)
433 struct nfsd4_session
*session
= cb
->cb_clp
->cl_cb_session
;
434 int status
= -ESERVERFAULT
;
439 * If the server returns different values for sessionID, slotID or
440 * sequence number, the server is looney tunes.
442 p
= xdr_inline_decode(xdr
, NFS4_MAX_SESSIONID_LEN
+ 4 + 4 + 4 + 4);
443 if (unlikely(p
== NULL
))
446 if (memcmp(p
, session
->se_sessionid
.data
, NFS4_MAX_SESSIONID_LEN
)) {
447 dprintk("NFS: %s Invalid session id\n", __func__
);
450 p
+= XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN
);
452 dummy
= be32_to_cpup(p
++);
453 if (dummy
!= session
->se_cb_seq_nr
) {
454 dprintk("NFS: %s Invalid sequence number\n", __func__
);
458 dummy
= be32_to_cpup(p
++);
460 dprintk("NFS: %s Invalid slotid\n", __func__
);
465 * FIXME: process highest slotid and target highest slotid
469 cb
->cb_seq_status
= status
;
476 static int decode_cb_sequence4res(struct xdr_stream
*xdr
,
477 struct nfsd4_callback
*cb
)
481 if (cb
->cb_clp
->cl_minorversion
== 0)
484 status
= decode_cb_op_status(xdr
, OP_CB_SEQUENCE
, &cb
->cb_seq_status
);
485 if (unlikely(status
|| cb
->cb_seq_status
))
488 return decode_cb_sequence4resok(xdr
, cb
);
492 * NFSv4.0 and NFSv4.1 XDR encode functions
494 * NFSv4.0 callback argument types are defined in section 15 of RFC
495 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
496 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
501 * NB: Without this zero space reservation, callbacks over krb5p fail
503 static void nfs4_xdr_enc_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
504 const void *__unused
)
506 xdr_reserve_space(xdr
, 0);
510 * 20.1. Operation 3: CB_GETATTR - Get Attributes
512 static void nfs4_xdr_enc_cb_getattr(struct rpc_rqst
*req
,
513 struct xdr_stream
*xdr
, const void *data
)
515 const struct nfsd4_callback
*cb
= data
;
516 struct nfs4_cb_fattr
*ncf
=
517 container_of(cb
, struct nfs4_cb_fattr
, ncf_getattr
);
518 struct nfs4_cb_compound_hdr hdr
= {
519 .ident
= cb
->cb_clp
->cl_cb_ident
,
520 .minorversion
= cb
->cb_clp
->cl_minorversion
,
523 encode_cb_compound4args(xdr
, &hdr
);
524 encode_cb_sequence4args(xdr
, cb
, &hdr
);
525 encode_cb_getattr4args(xdr
, &hdr
, ncf
);
526 encode_cb_nops(&hdr
);
530 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
532 static void nfs4_xdr_enc_cb_recall(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
535 const struct nfsd4_callback
*cb
= data
;
536 const struct nfs4_delegation
*dp
= cb_to_delegation(cb
);
537 struct nfs4_cb_compound_hdr hdr
= {
538 .ident
= cb
->cb_clp
->cl_cb_ident
,
539 .minorversion
= cb
->cb_clp
->cl_minorversion
,
542 encode_cb_compound4args(xdr
, &hdr
);
543 encode_cb_sequence4args(xdr
, cb
, &hdr
);
544 encode_cb_recall4args(xdr
, dp
, &hdr
);
545 encode_cb_nops(&hdr
);
549 * 20.6. Operation 8: CB_RECALL_ANY - Keep Any N Recallable Objects
552 nfs4_xdr_enc_cb_recall_any(struct rpc_rqst
*req
,
553 struct xdr_stream
*xdr
, const void *data
)
555 const struct nfsd4_callback
*cb
= data
;
556 struct nfsd4_cb_recall_any
*ra
;
557 struct nfs4_cb_compound_hdr hdr
= {
558 .ident
= cb
->cb_clp
->cl_cb_ident
,
559 .minorversion
= cb
->cb_clp
->cl_minorversion
,
562 ra
= container_of(cb
, struct nfsd4_cb_recall_any
, ra_cb
);
563 encode_cb_compound4args(xdr
, &hdr
);
564 encode_cb_sequence4args(xdr
, cb
, &hdr
);
565 encode_cb_recallany4args(xdr
, &hdr
, ra
);
566 encode_cb_nops(&hdr
);
570 * NFSv4.0 and NFSv4.1 XDR decode functions
572 * NFSv4.0 callback result types are defined in section 15 of RFC
573 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
574 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
578 static int nfs4_xdr_dec_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
585 * 20.1. Operation 3: CB_GETATTR - Get Attributes
587 static int nfs4_xdr_dec_cb_getattr(struct rpc_rqst
*rqstp
,
588 struct xdr_stream
*xdr
,
591 struct nfsd4_callback
*cb
= data
;
592 struct nfs4_cb_compound_hdr hdr
;
596 struct nfs4_cb_fattr
*ncf
=
597 container_of(cb
, struct nfs4_cb_fattr
, ncf_getattr
);
599 status
= decode_cb_compound4res(xdr
, &hdr
);
600 if (unlikely(status
))
603 status
= decode_cb_sequence4res(xdr
, cb
);
604 if (unlikely(status
|| cb
->cb_seq_status
))
607 status
= decode_cb_op_status(xdr
, OP_CB_GETATTR
, &cb
->cb_status
);
610 if (xdr_stream_decode_uint32_array(xdr
, bitmap
, 3) < 0)
611 return -NFSERR_BAD_XDR
;
612 if (xdr_stream_decode_u32(xdr
, &attrlen
) < 0)
613 return -NFSERR_BAD_XDR
;
614 if (attrlen
> (sizeof(ncf
->ncf_cb_change
) + sizeof(ncf
->ncf_cb_fsize
)))
615 return -NFSERR_BAD_XDR
;
616 status
= decode_cb_fattr4(xdr
, bitmap
, ncf
);
621 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
623 static int nfs4_xdr_dec_cb_recall(struct rpc_rqst
*rqstp
,
624 struct xdr_stream
*xdr
,
627 struct nfsd4_callback
*cb
= data
;
628 struct nfs4_cb_compound_hdr hdr
;
631 status
= decode_cb_compound4res(xdr
, &hdr
);
632 if (unlikely(status
))
635 status
= decode_cb_sequence4res(xdr
, cb
);
636 if (unlikely(status
|| cb
->cb_seq_status
))
639 return decode_cb_op_status(xdr
, OP_CB_RECALL
, &cb
->cb_status
);
643 * 20.6. Operation 8: CB_RECALL_ANY - Keep Any N Recallable Objects
646 nfs4_xdr_dec_cb_recall_any(struct rpc_rqst
*rqstp
,
647 struct xdr_stream
*xdr
,
650 struct nfsd4_callback
*cb
= data
;
651 struct nfs4_cb_compound_hdr hdr
;
654 status
= decode_cb_compound4res(xdr
, &hdr
);
655 if (unlikely(status
))
657 status
= decode_cb_sequence4res(xdr
, cb
);
658 if (unlikely(status
|| cb
->cb_seq_status
))
660 status
= decode_cb_op_status(xdr
, OP_CB_RECALL_ANY
, &cb
->cb_status
);
664 #ifdef CONFIG_NFSD_PNFS
666 * CB_LAYOUTRECALL4args
668 * struct layoutrecall_file4 {
670 * offset4 lor_offset;
671 * length4 lor_length;
672 * stateid4 lor_stateid;
675 * union layoutrecall4 switch(layoutrecall_type4 lor_recalltype) {
676 * case LAYOUTRECALL4_FILE:
677 * layoutrecall_file4 lor_layout;
678 * case LAYOUTRECALL4_FSID:
680 * case LAYOUTRECALL4_ALL:
684 * struct CB_LAYOUTRECALL4args {
685 * layouttype4 clora_type;
686 * layoutiomode4 clora_iomode;
687 * bool clora_changed;
688 * layoutrecall4 clora_recall;
691 static void encode_cb_layout4args(struct xdr_stream
*xdr
,
692 const struct nfs4_layout_stateid
*ls
,
693 struct nfs4_cb_compound_hdr
*hdr
)
697 BUG_ON(hdr
->minorversion
== 0);
699 p
= xdr_reserve_space(xdr
, 5 * 4);
700 *p
++ = cpu_to_be32(OP_CB_LAYOUTRECALL
);
701 *p
++ = cpu_to_be32(ls
->ls_layout_type
);
702 *p
++ = cpu_to_be32(IOMODE_ANY
);
703 *p
++ = cpu_to_be32(1);
704 *p
= cpu_to_be32(RETURN_FILE
);
706 encode_nfs_fh4(xdr
, &ls
->ls_stid
.sc_file
->fi_fhandle
);
708 p
= xdr_reserve_space(xdr
, 2 * 8);
709 p
= xdr_encode_hyper(p
, 0);
710 xdr_encode_hyper(p
, NFS4_MAX_UINT64
);
712 encode_stateid4(xdr
, &ls
->ls_recall_sid
);
717 static void nfs4_xdr_enc_cb_layout(struct rpc_rqst
*req
,
718 struct xdr_stream
*xdr
,
721 const struct nfsd4_callback
*cb
= data
;
722 const struct nfs4_layout_stateid
*ls
=
723 container_of(cb
, struct nfs4_layout_stateid
, ls_recall
);
724 struct nfs4_cb_compound_hdr hdr
= {
726 .minorversion
= cb
->cb_clp
->cl_minorversion
,
729 encode_cb_compound4args(xdr
, &hdr
);
730 encode_cb_sequence4args(xdr
, cb
, &hdr
);
731 encode_cb_layout4args(xdr
, ls
, &hdr
);
732 encode_cb_nops(&hdr
);
735 static int nfs4_xdr_dec_cb_layout(struct rpc_rqst
*rqstp
,
736 struct xdr_stream
*xdr
,
739 struct nfsd4_callback
*cb
= data
;
740 struct nfs4_cb_compound_hdr hdr
;
743 status
= decode_cb_compound4res(xdr
, &hdr
);
744 if (unlikely(status
))
747 status
= decode_cb_sequence4res(xdr
, cb
);
748 if (unlikely(status
|| cb
->cb_seq_status
))
751 return decode_cb_op_status(xdr
, OP_CB_LAYOUTRECALL
, &cb
->cb_status
);
753 #endif /* CONFIG_NFSD_PNFS */
755 static void encode_stateowner(struct xdr_stream
*xdr
, struct nfs4_stateowner
*so
)
759 p
= xdr_reserve_space(xdr
, 8 + 4 + so
->so_owner
.len
);
760 p
= xdr_encode_opaque_fixed(p
, &so
->so_client
->cl_clientid
, 8);
761 xdr_encode_opaque(p
, so
->so_owner
.data
, so
->so_owner
.len
);
764 static void nfs4_xdr_enc_cb_notify_lock(struct rpc_rqst
*req
,
765 struct xdr_stream
*xdr
,
768 const struct nfsd4_callback
*cb
= data
;
769 const struct nfsd4_blocked_lock
*nbl
=
770 container_of(cb
, struct nfsd4_blocked_lock
, nbl_cb
);
771 struct nfs4_lockowner
*lo
= (struct nfs4_lockowner
*)nbl
->nbl_lock
.fl_owner
;
772 struct nfs4_cb_compound_hdr hdr
= {
774 .minorversion
= cb
->cb_clp
->cl_minorversion
,
779 BUG_ON(hdr
.minorversion
== 0);
781 encode_cb_compound4args(xdr
, &hdr
);
782 encode_cb_sequence4args(xdr
, cb
, &hdr
);
784 p
= xdr_reserve_space(xdr
, 4);
785 *p
= cpu_to_be32(OP_CB_NOTIFY_LOCK
);
786 encode_nfs_fh4(xdr
, &nbl
->nbl_fh
);
787 encode_stateowner(xdr
, &lo
->lo_owner
);
790 encode_cb_nops(&hdr
);
793 static int nfs4_xdr_dec_cb_notify_lock(struct rpc_rqst
*rqstp
,
794 struct xdr_stream
*xdr
,
797 struct nfsd4_callback
*cb
= data
;
798 struct nfs4_cb_compound_hdr hdr
;
801 status
= decode_cb_compound4res(xdr
, &hdr
);
802 if (unlikely(status
))
805 status
= decode_cb_sequence4res(xdr
, cb
);
806 if (unlikely(status
|| cb
->cb_seq_status
))
809 return decode_cb_op_status(xdr
, OP_CB_NOTIFY_LOCK
, &cb
->cb_status
);
813 * struct write_response4 {
814 * stateid4 wr_callback_id<1>;
816 * stable_how4 wr_committed;
817 * verifier4 wr_writeverf;
819 * union offload_info4 switch (nfsstat4 coa_status) {
821 * write_response4 coa_resok4;
823 * length4 coa_bytes_copied;
825 * struct CB_OFFLOAD4args {
827 * stateid4 coa_stateid;
828 * offload_info4 coa_offload_info;
831 static void encode_offload_info4(struct xdr_stream
*xdr
,
832 const struct nfsd4_cb_offload
*cbo
)
836 p
= xdr_reserve_space(xdr
, 4);
838 switch (cbo
->co_nfserr
) {
840 p
= xdr_reserve_space(xdr
, 4 + 8 + 4 + NFS4_VERIFIER_SIZE
);
841 p
= xdr_encode_empty_array(p
);
842 p
= xdr_encode_hyper(p
, cbo
->co_res
.wr_bytes_written
);
843 *p
++ = cpu_to_be32(cbo
->co_res
.wr_stable_how
);
844 p
= xdr_encode_opaque_fixed(p
, cbo
->co_res
.wr_verifier
.data
,
848 p
= xdr_reserve_space(xdr
, 8);
849 /* We always return success if bytes were written */
850 p
= xdr_encode_hyper(p
, 0);
854 static void encode_cb_offload4args(struct xdr_stream
*xdr
,
855 const struct nfsd4_cb_offload
*cbo
,
856 struct nfs4_cb_compound_hdr
*hdr
)
860 p
= xdr_reserve_space(xdr
, 4);
861 *p
= cpu_to_be32(OP_CB_OFFLOAD
);
862 encode_nfs_fh4(xdr
, &cbo
->co_fh
);
863 encode_stateid4(xdr
, &cbo
->co_res
.cb_stateid
);
864 encode_offload_info4(xdr
, cbo
);
869 static void nfs4_xdr_enc_cb_offload(struct rpc_rqst
*req
,
870 struct xdr_stream
*xdr
,
873 const struct nfsd4_callback
*cb
= data
;
874 const struct nfsd4_cb_offload
*cbo
=
875 container_of(cb
, struct nfsd4_cb_offload
, co_cb
);
876 struct nfs4_cb_compound_hdr hdr
= {
878 .minorversion
= cb
->cb_clp
->cl_minorversion
,
881 encode_cb_compound4args(xdr
, &hdr
);
882 encode_cb_sequence4args(xdr
, cb
, &hdr
);
883 encode_cb_offload4args(xdr
, cbo
, &hdr
);
884 encode_cb_nops(&hdr
);
887 static int nfs4_xdr_dec_cb_offload(struct rpc_rqst
*rqstp
,
888 struct xdr_stream
*xdr
,
891 struct nfsd4_callback
*cb
= data
;
892 struct nfs4_cb_compound_hdr hdr
;
895 status
= decode_cb_compound4res(xdr
, &hdr
);
896 if (unlikely(status
))
899 status
= decode_cb_sequence4res(xdr
, cb
);
900 if (unlikely(status
|| cb
->cb_seq_status
))
903 return decode_cb_op_status(xdr
, OP_CB_OFFLOAD
, &cb
->cb_status
);
906 * RPC procedure tables
908 #define PROC(proc, call, argtype, restype) \
909 [NFSPROC4_CLNT_##proc] = { \
910 .p_proc = NFSPROC4_CB_##call, \
911 .p_encode = nfs4_xdr_enc_##argtype, \
912 .p_decode = nfs4_xdr_dec_##restype, \
913 .p_arglen = NFS4_enc_##argtype##_sz, \
914 .p_replen = NFS4_dec_##restype##_sz, \
915 .p_statidx = NFSPROC4_CB_##call, \
919 static const struct rpc_procinfo nfs4_cb_procedures
[] = {
920 PROC(CB_NULL
, NULL
, cb_null
, cb_null
),
921 PROC(CB_RECALL
, COMPOUND
, cb_recall
, cb_recall
),
922 #ifdef CONFIG_NFSD_PNFS
923 PROC(CB_LAYOUT
, COMPOUND
, cb_layout
, cb_layout
),
925 PROC(CB_NOTIFY_LOCK
, COMPOUND
, cb_notify_lock
, cb_notify_lock
),
926 PROC(CB_OFFLOAD
, COMPOUND
, cb_offload
, cb_offload
),
927 PROC(CB_RECALL_ANY
, COMPOUND
, cb_recall_any
, cb_recall_any
),
928 PROC(CB_GETATTR
, COMPOUND
, cb_getattr
, cb_getattr
),
931 static unsigned int nfs4_cb_counts
[ARRAY_SIZE(nfs4_cb_procedures
)];
932 static const struct rpc_version nfs_cb_version4
= {
934 * Note on the callback rpc program version number: despite language in rfc
935 * 5661 section 18.36.3 requiring servers to use 4 in this field, the
936 * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
937 * in practice that appears to be what implementations use. The section
938 * 18.36.3 language is expected to be fixed in an erratum.
941 .nrprocs
= ARRAY_SIZE(nfs4_cb_procedures
),
942 .procs
= nfs4_cb_procedures
,
943 .counts
= nfs4_cb_counts
,
946 static const struct rpc_version
*nfs_cb_version
[2] = {
947 [1] = &nfs_cb_version4
,
950 static const struct rpc_program cb_program
;
952 static struct rpc_stat cb_stats
= {
953 .program
= &cb_program
956 #define NFS4_CALLBACK 0x40000000
957 static const struct rpc_program cb_program
= {
959 .number
= NFS4_CALLBACK
,
960 .nrvers
= ARRAY_SIZE(nfs_cb_version
),
961 .version
= nfs_cb_version
,
963 .pipe_dir_name
= "nfsd4_cb",
966 static int max_cb_time(struct net
*net
)
968 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
971 * nfsd4_lease is set to at most one hour in __nfsd4_write_time,
972 * so we can use 32-bit math on it. Warn if that assumption
973 * ever stops being true.
975 if (WARN_ON_ONCE(nn
->nfsd4_lease
> 3600))
978 return max(((u32
)nn
->nfsd4_lease
)/10, 1u) * HZ
;
981 static struct workqueue_struct
*callback_wq
;
983 static bool nfsd4_queue_cb(struct nfsd4_callback
*cb
)
985 trace_nfsd_cb_queue(cb
->cb_clp
, cb
);
986 return queue_work(callback_wq
, &cb
->cb_work
);
989 static void nfsd41_cb_inflight_begin(struct nfs4_client
*clp
)
991 atomic_inc(&clp
->cl_cb_inflight
);
994 static void nfsd41_cb_inflight_end(struct nfs4_client
*clp
)
997 if (atomic_dec_and_test(&clp
->cl_cb_inflight
))
998 wake_up_var(&clp
->cl_cb_inflight
);
1001 static void nfsd41_cb_inflight_wait_complete(struct nfs4_client
*clp
)
1003 wait_var_event(&clp
->cl_cb_inflight
,
1004 !atomic_read(&clp
->cl_cb_inflight
));
1007 static const struct cred
*get_backchannel_cred(struct nfs4_client
*clp
, struct rpc_clnt
*client
, struct nfsd4_session
*ses
)
1009 if (clp
->cl_minorversion
== 0) {
1010 client
->cl_principal
= clp
->cl_cred
.cr_targ_princ
?
1011 clp
->cl_cred
.cr_targ_princ
: "nfs";
1013 return get_cred(rpc_machine_cred());
1017 kcred
= prepare_kernel_cred(&init_task
);
1021 kcred
->fsuid
= ses
->se_cb_sec
.uid
;
1022 kcred
->fsgid
= ses
->se_cb_sec
.gid
;
1027 static int setup_callback_client(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
, struct nfsd4_session
*ses
)
1029 int maxtime
= max_cb_time(clp
->net
);
1030 struct rpc_timeout timeparms
= {
1031 .to_initval
= maxtime
,
1033 .to_maxval
= maxtime
,
1035 struct rpc_create_args args
= {
1037 .address
= (struct sockaddr
*) &conn
->cb_addr
,
1038 .addrsize
= conn
->cb_addrlen
,
1039 .saddress
= (struct sockaddr
*) &conn
->cb_saddr
,
1040 .timeout
= &timeparms
,
1041 .program
= &cb_program
,
1043 .flags
= (RPC_CLNT_CREATE_NOPING
| RPC_CLNT_CREATE_QUIET
),
1044 .cred
= current_cred(),
1046 struct rpc_clnt
*client
;
1047 const struct cred
*cred
;
1049 if (clp
->cl_minorversion
== 0) {
1050 if (!clp
->cl_cred
.cr_principal
&&
1051 (clp
->cl_cred
.cr_flavor
>= RPC_AUTH_GSS_KRB5
)) {
1052 trace_nfsd_cb_setup_err(clp
, -EINVAL
);
1055 args
.client_name
= clp
->cl_cred
.cr_principal
;
1056 args
.prognumber
= conn
->cb_prog
;
1057 args
.protocol
= XPRT_TRANSPORT_TCP
;
1058 args
.authflavor
= clp
->cl_cred
.cr_flavor
;
1059 clp
->cl_cb_ident
= conn
->cb_ident
;
1063 clp
->cl_cb_session
= ses
;
1064 args
.bc_xprt
= conn
->cb_xprt
;
1065 args
.prognumber
= clp
->cl_cb_session
->se_cb_prog
;
1066 args
.protocol
= conn
->cb_xprt
->xpt_class
->xcl_ident
|
1068 args
.authflavor
= ses
->se_cb_sec
.flavor
;
1070 /* Create RPC client */
1071 client
= rpc_create(&args
);
1072 if (IS_ERR(client
)) {
1073 trace_nfsd_cb_setup_err(clp
, PTR_ERR(client
));
1074 return PTR_ERR(client
);
1076 cred
= get_backchannel_cred(clp
, client
, ses
);
1078 trace_nfsd_cb_setup_err(clp
, -ENOMEM
);
1079 rpc_shutdown_client(client
);
1083 if (clp
->cl_minorversion
!= 0)
1084 clp
->cl_cb_conn
.cb_xprt
= conn
->cb_xprt
;
1085 clp
->cl_cb_client
= client
;
1086 clp
->cl_cb_cred
= cred
;
1088 trace_nfsd_cb_setup(clp
, rpc_peeraddr2str(client
, RPC_DISPLAY_NETID
),
1094 static void nfsd4_mark_cb_state(struct nfs4_client
*clp
, int newstate
)
1096 if (clp
->cl_cb_state
!= newstate
) {
1097 clp
->cl_cb_state
= newstate
;
1098 trace_nfsd_cb_new_state(clp
);
1102 static void nfsd4_mark_cb_down(struct nfs4_client
*clp
)
1104 if (test_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
))
1106 nfsd4_mark_cb_state(clp
, NFSD4_CB_DOWN
);
1109 static void nfsd4_mark_cb_fault(struct nfs4_client
*clp
)
1111 if (test_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
))
1113 nfsd4_mark_cb_state(clp
, NFSD4_CB_FAULT
);
1116 static void nfsd4_cb_probe_done(struct rpc_task
*task
, void *calldata
)
1118 struct nfs4_client
*clp
= container_of(calldata
, struct nfs4_client
, cl_cb_null
);
1120 if (task
->tk_status
)
1121 nfsd4_mark_cb_down(clp
);
1123 nfsd4_mark_cb_state(clp
, NFSD4_CB_UP
);
1126 static void nfsd4_cb_probe_release(void *calldata
)
1128 struct nfs4_client
*clp
= container_of(calldata
, struct nfs4_client
, cl_cb_null
);
1130 nfsd41_cb_inflight_end(clp
);
1134 static const struct rpc_call_ops nfsd4_cb_probe_ops
= {
1135 /* XXX: release method to ensure we set the cb channel down if
1136 * necessary on early failure? */
1137 .rpc_call_done
= nfsd4_cb_probe_done
,
1138 .rpc_release
= nfsd4_cb_probe_release
,
1142 * Poke the callback thread to process any updates to the callback
1143 * parameters, and send a null probe.
1145 void nfsd4_probe_callback(struct nfs4_client
*clp
)
1147 trace_nfsd_cb_probe(clp
);
1148 nfsd4_mark_cb_state(clp
, NFSD4_CB_UNKNOWN
);
1149 set_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
);
1150 nfsd4_run_cb(&clp
->cl_cb_null
);
1153 void nfsd4_probe_callback_sync(struct nfs4_client
*clp
)
1155 nfsd4_probe_callback(clp
);
1156 flush_workqueue(callback_wq
);
1159 void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
1161 nfsd4_mark_cb_state(clp
, NFSD4_CB_UNKNOWN
);
1162 spin_lock(&clp
->cl_lock
);
1163 memcpy(&clp
->cl_cb_conn
, conn
, sizeof(struct nfs4_cb_conn
));
1164 spin_unlock(&clp
->cl_lock
);
1168 * There's currently a single callback channel slot.
1169 * If the slot is available, then mark it busy. Otherwise, set the
1170 * thread for sleeping on the callback RPC wait queue.
1172 static bool nfsd41_cb_get_slot(struct nfsd4_callback
*cb
, struct rpc_task
*task
)
1174 struct nfs4_client
*clp
= cb
->cb_clp
;
1176 if (!cb
->cb_holds_slot
&&
1177 test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
1178 rpc_sleep_on(&clp
->cl_cb_waitq
, task
, NULL
);
1180 if (test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
1181 dprintk("%s slot is busy\n", __func__
);
1184 rpc_wake_up_queued_task(&clp
->cl_cb_waitq
, task
);
1186 cb
->cb_holds_slot
= true;
1190 static void nfsd41_cb_release_slot(struct nfsd4_callback
*cb
)
1192 struct nfs4_client
*clp
= cb
->cb_clp
;
1194 if (cb
->cb_holds_slot
) {
1195 cb
->cb_holds_slot
= false;
1196 clear_bit(0, &clp
->cl_cb_slot_busy
);
1197 rpc_wake_up_next(&clp
->cl_cb_waitq
);
1201 static void nfsd41_destroy_cb(struct nfsd4_callback
*cb
)
1203 struct nfs4_client
*clp
= cb
->cb_clp
;
1205 trace_nfsd_cb_destroy(clp
, cb
);
1206 nfsd41_cb_release_slot(cb
);
1207 if (cb
->cb_ops
&& cb
->cb_ops
->release
)
1208 cb
->cb_ops
->release(cb
);
1209 nfsd41_cb_inflight_end(clp
);
1213 * TODO: cb_sequence should support referring call lists, cachethis, multiple
1214 * slots, and mark callback channel down on communication errors.
1216 static void nfsd4_cb_prepare(struct rpc_task
*task
, void *calldata
)
1218 struct nfsd4_callback
*cb
= calldata
;
1219 struct nfs4_client
*clp
= cb
->cb_clp
;
1220 u32 minorversion
= clp
->cl_minorversion
;
1223 * cb_seq_status is only set in decode_cb_sequence4res,
1224 * and so will remain 1 if an rpc level failure occurs.
1226 cb
->cb_seq_status
= 1;
1228 if (minorversion
&& !nfsd41_cb_get_slot(cb
, task
))
1230 rpc_call_start(task
);
1233 static bool nfsd4_cb_sequence_done(struct rpc_task
*task
, struct nfsd4_callback
*cb
)
1235 struct nfs4_client
*clp
= cb
->cb_clp
;
1236 struct nfsd4_session
*session
= clp
->cl_cb_session
;
1239 if (!clp
->cl_minorversion
) {
1241 * If the backchannel connection was shut down while this
1242 * task was queued, we need to resubmit it after setting up
1243 * a new backchannel connection.
1245 * Note that if we lost our callback connection permanently
1246 * the submission code will error out, so we don't need to
1247 * handle that case here.
1249 if (RPC_SIGNALLED(task
))
1255 if (!cb
->cb_holds_slot
)
1258 /* This is the operation status code for CB_SEQUENCE */
1259 trace_nfsd_cb_seq_status(task
, cb
);
1260 switch (cb
->cb_seq_status
) {
1263 * No need for lock, access serialized in nfsd4_cb_prepare
1266 * If CB_SEQUENCE returns an error, then the state of the slot
1267 * (sequence ID, cached reply) MUST NOT change.
1269 ++session
->se_cb_seq_nr
;
1272 ++session
->se_cb_seq_nr
;
1273 nfsd4_mark_cb_fault(cb
->cb_clp
);
1278 * cb_seq_status remains 1 if an RPC Reply was never
1279 * received. NFSD can't know if the client processed
1280 * the CB_SEQUENCE operation. Ask the client to send a
1281 * DESTROY_SESSION to recover.
1284 case -NFS4ERR_BADSESSION
:
1285 nfsd4_mark_cb_fault(cb
->cb_clp
);
1288 case -NFS4ERR_DELAY
:
1289 cb
->cb_seq_status
= 1;
1290 if (!rpc_restart_call(task
))
1293 rpc_delay(task
, 2 * HZ
);
1295 case -NFS4ERR_BADSLOT
:
1297 case -NFS4ERR_SEQ_MISORDERED
:
1298 if (session
->se_cb_seq_nr
!= 1) {
1299 session
->se_cb_seq_nr
= 1;
1304 nfsd4_mark_cb_fault(cb
->cb_clp
);
1306 nfsd41_cb_release_slot(cb
);
1308 trace_nfsd_cb_free_slot(task
, cb
);
1310 if (RPC_SIGNALLED(task
))
1315 if (rpc_restart_call_prepare(task
))
1319 if (!test_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
)) {
1320 trace_nfsd_cb_restart(clp
, cb
);
1321 task
->tk_status
= 0;
1322 cb
->cb_need_restart
= true;
1327 static void nfsd4_cb_done(struct rpc_task
*task
, void *calldata
)
1329 struct nfsd4_callback
*cb
= calldata
;
1330 struct nfs4_client
*clp
= cb
->cb_clp
;
1332 if (!nfsd4_cb_sequence_done(task
, cb
))
1335 if (cb
->cb_status
) {
1336 WARN_ON_ONCE(task
->tk_status
);
1337 task
->tk_status
= cb
->cb_status
;
1340 switch (cb
->cb_ops
->done(cb
, task
)) {
1342 task
->tk_status
= 0;
1343 rpc_restart_call_prepare(task
);
1346 switch (task
->tk_status
) {
1350 nfsd4_mark_cb_down(clp
);
1358 static void nfsd4_cb_release(void *calldata
)
1360 struct nfsd4_callback
*cb
= calldata
;
1362 if (cb
->cb_need_restart
)
1365 nfsd41_destroy_cb(cb
);
1369 static const struct rpc_call_ops nfsd4_cb_ops
= {
1370 .rpc_call_prepare
= nfsd4_cb_prepare
,
1371 .rpc_call_done
= nfsd4_cb_done
,
1372 .rpc_release
= nfsd4_cb_release
,
1375 int nfsd4_create_callback_queue(void)
1377 callback_wq
= alloc_ordered_workqueue("nfsd4_callbacks", 0);
1383 void nfsd4_destroy_callback_queue(void)
1385 destroy_workqueue(callback_wq
);
1388 /* must be called under the state lock */
1389 void nfsd4_shutdown_callback(struct nfs4_client
*clp
)
1391 if (clp
->cl_cb_state
!= NFSD4_CB_UNKNOWN
)
1392 trace_nfsd_cb_shutdown(clp
);
1394 set_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
);
1396 * Note this won't actually result in a null callback;
1397 * instead, nfsd4_run_cb_null() will detect the killed
1398 * client, destroy the rpc client, and stop:
1400 nfsd4_run_cb(&clp
->cl_cb_null
);
1401 flush_workqueue(callback_wq
);
1402 nfsd41_cb_inflight_wait_complete(clp
);
1405 static struct nfsd4_conn
* __nfsd4_find_backchannel(struct nfs4_client
*clp
)
1407 struct nfsd4_session
*s
;
1408 struct nfsd4_conn
*c
;
1410 lockdep_assert_held(&clp
->cl_lock
);
1412 list_for_each_entry(s
, &clp
->cl_sessions
, se_perclnt
) {
1413 list_for_each_entry(c
, &s
->se_conns
, cn_persession
) {
1414 if (c
->cn_flags
& NFS4_CDFC4_BACK
)
1422 * Note there isn't a lot of locking in this code; instead we depend on
1423 * the fact that it is run from the callback_wq, which won't run two
1424 * work items at once. So, for example, callback_wq handles all access
1425 * of cl_cb_client and all calls to rpc_create or rpc_shutdown_client.
1427 static void nfsd4_process_cb_update(struct nfsd4_callback
*cb
)
1429 struct nfs4_cb_conn conn
;
1430 struct nfs4_client
*clp
= cb
->cb_clp
;
1431 struct nfsd4_session
*ses
= NULL
;
1432 struct nfsd4_conn
*c
;
1435 trace_nfsd_cb_bc_update(clp
, cb
);
1438 * This is either an update, or the client dying; in either case,
1439 * kill the old client:
1441 if (clp
->cl_cb_client
) {
1442 trace_nfsd_cb_bc_shutdown(clp
, cb
);
1443 rpc_shutdown_client(clp
->cl_cb_client
);
1444 clp
->cl_cb_client
= NULL
;
1445 put_cred(clp
->cl_cb_cred
);
1446 clp
->cl_cb_cred
= NULL
;
1448 if (clp
->cl_cb_conn
.cb_xprt
) {
1449 svc_xprt_put(clp
->cl_cb_conn
.cb_xprt
);
1450 clp
->cl_cb_conn
.cb_xprt
= NULL
;
1452 if (test_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
))
1455 spin_lock(&clp
->cl_lock
);
1457 * Only serialized callback code is allowed to clear these
1458 * flags; main nfsd code can only set them:
1460 WARN_ON(!(clp
->cl_flags
& NFSD4_CLIENT_CB_FLAG_MASK
));
1461 clear_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
);
1463 memcpy(&conn
, &cb
->cb_clp
->cl_cb_conn
, sizeof(struct nfs4_cb_conn
));
1464 c
= __nfsd4_find_backchannel(clp
);
1466 svc_xprt_get(c
->cn_xprt
);
1467 conn
.cb_xprt
= c
->cn_xprt
;
1468 ses
= c
->cn_session
;
1470 spin_unlock(&clp
->cl_lock
);
1472 err
= setup_callback_client(clp
, &conn
, ses
);
1474 nfsd4_mark_cb_down(clp
);
1476 svc_xprt_put(c
->cn_xprt
);
1482 nfsd4_run_cb_work(struct work_struct
*work
)
1484 struct nfsd4_callback
*cb
=
1485 container_of(work
, struct nfsd4_callback
, cb_work
);
1486 struct nfs4_client
*clp
= cb
->cb_clp
;
1487 struct rpc_clnt
*clnt
;
1490 trace_nfsd_cb_start(clp
);
1492 if (clp
->cl_flags
& NFSD4_CLIENT_CB_FLAG_MASK
)
1493 nfsd4_process_cb_update(cb
);
1495 clnt
= clp
->cl_cb_client
;
1497 /* Callback channel broken, or client killed; give up: */
1498 nfsd41_destroy_cb(cb
);
1503 * Don't send probe messages for 4.1 or later.
1505 if (!cb
->cb_ops
&& clp
->cl_minorversion
) {
1506 nfsd4_mark_cb_state(clp
, NFSD4_CB_UP
);
1507 nfsd41_destroy_cb(cb
);
1511 if (cb
->cb_need_restart
) {
1512 cb
->cb_need_restart
= false;
1514 if (cb
->cb_ops
&& cb
->cb_ops
->prepare
)
1515 cb
->cb_ops
->prepare(cb
);
1517 cb
->cb_msg
.rpc_cred
= clp
->cl_cb_cred
;
1518 flags
= clp
->cl_minorversion
? RPC_TASK_NOCONNECT
: RPC_TASK_SOFTCONN
;
1519 rpc_call_async(clnt
, &cb
->cb_msg
, RPC_TASK_SOFT
| flags
,
1520 cb
->cb_ops
? &nfsd4_cb_ops
: &nfsd4_cb_probe_ops
, cb
);
1523 void nfsd4_init_cb(struct nfsd4_callback
*cb
, struct nfs4_client
*clp
,
1524 const struct nfsd4_callback_ops
*ops
, enum nfsd4_cb_op op
)
1527 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[op
];
1528 cb
->cb_msg
.rpc_argp
= cb
;
1529 cb
->cb_msg
.rpc_resp
= cb
;
1531 INIT_WORK(&cb
->cb_work
, nfsd4_run_cb_work
);
1533 cb
->cb_need_restart
= false;
1534 cb
->cb_holds_slot
= false;
1538 * nfsd4_run_cb - queue up a callback job to run
1539 * @cb: callback to queue
1541 * Kick off a callback to do its thing. Returns false if it was already
1542 * on a queue, true otherwise.
1544 bool nfsd4_run_cb(struct nfsd4_callback
*cb
)
1546 struct nfs4_client
*clp
= cb
->cb_clp
;
1549 nfsd41_cb_inflight_begin(clp
);
1550 queued
= nfsd4_queue_cb(cb
);
1552 nfsd41_cb_inflight_end(clp
);