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/sunrpc/clnt.h>
35 #include <linux/sunrpc/xprt.h>
36 #include <linux/sunrpc/svc_xprt.h>
37 #include <linux/slab.h>
44 #define NFSDDBG_FACILITY NFSDDBG_PROC
46 static void nfsd4_mark_cb_fault(struct nfs4_client
*, int reason
);
48 #define NFSPROC4_CB_NULL 0
49 #define NFSPROC4_CB_COMPOUND 1
51 /* Index of predefined Linux callback client operations */
53 struct nfs4_cb_compound_hdr
{
55 u32 ident
; /* minorversion 0 only */
63 static __be32
*xdr_encode_empty_array(__be32
*p
)
70 * Encode/decode NFSv4 CB basic data types
72 * Basic NFSv4 callback data types are defined in section 15 of RFC
73 * 3530: "Network File System (NFS) version 4 Protocol" and section
74 * 20 of RFC 5661: "Network File System (NFS) Version 4 Minor Version
81 * enum nfs_cb_opnum4 {
89 OP_CB_LAYOUTRECALL
= 5,
93 OP_CB_RECALLABLE_OBJ_AVAIL
= 9,
94 OP_CB_RECALL_SLOT
= 10,
96 OP_CB_WANTS_CANCELLED
= 12,
97 OP_CB_NOTIFY_LOCK
= 13,
98 OP_CB_NOTIFY_DEVICEID
= 14,
100 OP_CB_ILLEGAL
= 10044
103 static void encode_nfs_cb_opnum4(struct xdr_stream
*xdr
, enum nfs_cb_opnum4 op
)
107 p
= xdr_reserve_space(xdr
, 4);
108 *p
= cpu_to_be32(op
);
114 * typedef opaque nfs_fh4<NFS4_FHSIZE>;
116 static void encode_nfs_fh4(struct xdr_stream
*xdr
, const struct knfsd_fh
*fh
)
118 u32 length
= fh
->fh_size
;
121 BUG_ON(length
> NFS4_FHSIZE
);
122 p
= xdr_reserve_space(xdr
, 4 + length
);
123 xdr_encode_opaque(p
, &fh
->fh_base
, length
);
134 static void encode_stateid4(struct xdr_stream
*xdr
, const stateid_t
*sid
)
138 p
= xdr_reserve_space(xdr
, NFS4_STATEID_SIZE
);
139 *p
++ = cpu_to_be32(sid
->si_generation
);
140 xdr_encode_opaque_fixed(p
, &sid
->si_opaque
, NFS4_STATEID_OTHER_SIZE
);
146 * typedef opaque sessionid4[NFS4_SESSIONID_SIZE];
148 static void encode_sessionid4(struct xdr_stream
*xdr
,
149 const struct nfsd4_session
*session
)
153 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
);
154 xdr_encode_opaque_fixed(p
, session
->se_sessionid
.data
,
155 NFS4_MAX_SESSIONID_LEN
);
161 static const struct {
164 } nfs_cb_errtbl
[] = {
166 { NFS4ERR_PERM
, -EPERM
},
167 { NFS4ERR_NOENT
, -ENOENT
},
168 { NFS4ERR_IO
, -EIO
},
169 { NFS4ERR_NXIO
, -ENXIO
},
170 { NFS4ERR_ACCESS
, -EACCES
},
171 { NFS4ERR_EXIST
, -EEXIST
},
172 { NFS4ERR_XDEV
, -EXDEV
},
173 { NFS4ERR_NOTDIR
, -ENOTDIR
},
174 { NFS4ERR_ISDIR
, -EISDIR
},
175 { NFS4ERR_INVAL
, -EINVAL
},
176 { NFS4ERR_FBIG
, -EFBIG
},
177 { NFS4ERR_NOSPC
, -ENOSPC
},
178 { NFS4ERR_ROFS
, -EROFS
},
179 { NFS4ERR_MLINK
, -EMLINK
},
180 { NFS4ERR_NAMETOOLONG
, -ENAMETOOLONG
},
181 { NFS4ERR_NOTEMPTY
, -ENOTEMPTY
},
182 { NFS4ERR_DQUOT
, -EDQUOT
},
183 { NFS4ERR_STALE
, -ESTALE
},
184 { NFS4ERR_BADHANDLE
, -EBADHANDLE
},
185 { NFS4ERR_BAD_COOKIE
, -EBADCOOKIE
},
186 { NFS4ERR_NOTSUPP
, -ENOTSUPP
},
187 { NFS4ERR_TOOSMALL
, -ETOOSMALL
},
188 { NFS4ERR_SERVERFAULT
, -ESERVERFAULT
},
189 { NFS4ERR_BADTYPE
, -EBADTYPE
},
190 { NFS4ERR_LOCKED
, -EAGAIN
},
191 { NFS4ERR_RESOURCE
, -EREMOTEIO
},
192 { NFS4ERR_SYMLINK
, -ELOOP
},
193 { NFS4ERR_OP_ILLEGAL
, -EOPNOTSUPP
},
194 { NFS4ERR_DEADLOCK
, -EDEADLK
},
199 * If we cannot translate the error, the recovery routines should
202 * Note: remaining NFSv4 error codes have values > 10000, so should
203 * not conflict with native Linux error codes.
205 static int nfs_cb_stat_to_errno(int status
)
209 for (i
= 0; nfs_cb_errtbl
[i
].stat
!= -1; i
++) {
210 if (nfs_cb_errtbl
[i
].stat
== status
)
211 return nfs_cb_errtbl
[i
].errno
;
214 dprintk("NFSD: Unrecognized NFS CB status value: %u\n", status
);
218 static int decode_cb_op_status(struct xdr_stream
*xdr
,
219 enum nfs_cb_opnum4 expected
, int *status
)
224 p
= xdr_inline_decode(xdr
, 4 + 4);
225 if (unlikely(p
== NULL
))
227 op
= be32_to_cpup(p
++);
228 if (unlikely(op
!= expected
))
230 *status
= nfs_cb_stat_to_errno(be32_to_cpup(p
));
235 dprintk("NFSD: Callback server returned operation %d but "
236 "we issued a request for %d\n", op
, expected
);
243 * struct CB_COMPOUND4args {
245 * uint32_t minorversion;
246 * uint32_t callback_ident;
247 * nfs_cb_argop4 argarray<>;
250 static void encode_cb_compound4args(struct xdr_stream
*xdr
,
251 struct nfs4_cb_compound_hdr
*hdr
)
255 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4);
256 p
= xdr_encode_empty_array(p
); /* empty tag */
257 *p
++ = cpu_to_be32(hdr
->minorversion
);
258 *p
++ = cpu_to_be32(hdr
->ident
);
261 *p
= cpu_to_be32(hdr
->nops
); /* argarray element count */
265 * Update argarray element count
267 static void encode_cb_nops(struct nfs4_cb_compound_hdr
*hdr
)
269 BUG_ON(hdr
->nops
> NFS4_MAX_BACK_CHANNEL_OPS
);
270 *hdr
->nops_p
= cpu_to_be32(hdr
->nops
);
276 * struct CB_COMPOUND4res {
279 * nfs_cb_resop4 resarray<>;
282 static int decode_cb_compound4res(struct xdr_stream
*xdr
,
283 struct nfs4_cb_compound_hdr
*hdr
)
288 p
= xdr_inline_decode(xdr
, 4 + 4);
289 if (unlikely(p
== NULL
))
291 hdr
->status
= be32_to_cpup(p
++);
293 length
= be32_to_cpup(p
++);
294 p
= xdr_inline_decode(xdr
, length
+ 4);
295 if (unlikely(p
== NULL
))
297 p
+= XDR_QUADLEN(length
);
298 hdr
->nops
= be32_to_cpup(p
);
307 * struct CB_RECALL4args {
313 static void encode_cb_recall4args(struct xdr_stream
*xdr
,
314 const struct nfs4_delegation
*dp
,
315 struct nfs4_cb_compound_hdr
*hdr
)
319 encode_nfs_cb_opnum4(xdr
, OP_CB_RECALL
);
320 encode_stateid4(xdr
, &dp
->dl_stid
.sc_stateid
);
322 p
= xdr_reserve_space(xdr
, 4);
323 *p
++ = xdr_zero
; /* truncate */
325 encode_nfs_fh4(xdr
, &dp
->dl_stid
.sc_file
->fi_fhandle
);
333 * struct CB_SEQUENCE4args {
334 * sessionid4 csa_sessionid;
335 * sequenceid4 csa_sequenceid;
336 * slotid4 csa_slotid;
337 * slotid4 csa_highest_slotid;
338 * bool csa_cachethis;
339 * referring_call_list4 csa_referring_call_lists<>;
342 static void encode_cb_sequence4args(struct xdr_stream
*xdr
,
343 const struct nfsd4_callback
*cb
,
344 struct nfs4_cb_compound_hdr
*hdr
)
346 struct nfsd4_session
*session
= cb
->cb_clp
->cl_cb_session
;
349 if (hdr
->minorversion
== 0)
352 encode_nfs_cb_opnum4(xdr
, OP_CB_SEQUENCE
);
353 encode_sessionid4(xdr
, session
);
355 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4 + 4);
356 *p
++ = cpu_to_be32(session
->se_cb_seq_nr
); /* csa_sequenceid */
357 *p
++ = xdr_zero
; /* csa_slotid */
358 *p
++ = xdr_zero
; /* csa_highest_slotid */
359 *p
++ = xdr_zero
; /* csa_cachethis */
360 xdr_encode_empty_array(p
); /* csa_referring_call_lists */
368 * struct CB_SEQUENCE4resok {
369 * sessionid4 csr_sessionid;
370 * sequenceid4 csr_sequenceid;
371 * slotid4 csr_slotid;
372 * slotid4 csr_highest_slotid;
373 * slotid4 csr_target_highest_slotid;
376 * union CB_SEQUENCE4res switch (nfsstat4 csr_status) {
378 * CB_SEQUENCE4resok csr_resok4;
383 * Our current back channel implmentation supports a single backchannel
384 * with a single slot.
386 static int decode_cb_sequence4resok(struct xdr_stream
*xdr
,
387 struct nfsd4_callback
*cb
)
389 struct nfsd4_session
*session
= cb
->cb_clp
->cl_cb_session
;
390 int status
= -ESERVERFAULT
;
395 * If the server returns different values for sessionID, slotID or
396 * sequence number, the server is looney tunes.
398 p
= xdr_inline_decode(xdr
, NFS4_MAX_SESSIONID_LEN
+ 4 + 4 + 4 + 4);
399 if (unlikely(p
== NULL
))
402 if (memcmp(p
, session
->se_sessionid
.data
, NFS4_MAX_SESSIONID_LEN
)) {
403 dprintk("NFS: %s Invalid session id\n", __func__
);
406 p
+= XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN
);
408 dummy
= be32_to_cpup(p
++);
409 if (dummy
!= session
->se_cb_seq_nr
) {
410 dprintk("NFS: %s Invalid sequence number\n", __func__
);
414 dummy
= be32_to_cpup(p
++);
416 dprintk("NFS: %s Invalid slotid\n", __func__
);
421 * FIXME: process highest slotid and target highest slotid
425 cb
->cb_seq_status
= status
;
432 static int decode_cb_sequence4res(struct xdr_stream
*xdr
,
433 struct nfsd4_callback
*cb
)
437 if (cb
->cb_clp
->cl_minorversion
== 0)
440 status
= decode_cb_op_status(xdr
, OP_CB_SEQUENCE
, &cb
->cb_seq_status
);
441 if (unlikely(status
|| cb
->cb_seq_status
))
444 return decode_cb_sequence4resok(xdr
, cb
);
448 * NFSv4.0 and NFSv4.1 XDR encode functions
450 * NFSv4.0 callback argument types are defined in section 15 of RFC
451 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
452 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
457 * NB: Without this zero space reservation, callbacks over krb5p fail
459 static void nfs4_xdr_enc_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
460 const void *__unused
)
462 xdr_reserve_space(xdr
, 0);
466 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
468 static void nfs4_xdr_enc_cb_recall(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
471 const struct nfsd4_callback
*cb
= data
;
472 const struct nfs4_delegation
*dp
= cb_to_delegation(cb
);
473 struct nfs4_cb_compound_hdr hdr
= {
474 .ident
= cb
->cb_clp
->cl_cb_ident
,
475 .minorversion
= cb
->cb_clp
->cl_minorversion
,
478 encode_cb_compound4args(xdr
, &hdr
);
479 encode_cb_sequence4args(xdr
, cb
, &hdr
);
480 encode_cb_recall4args(xdr
, dp
, &hdr
);
481 encode_cb_nops(&hdr
);
486 * NFSv4.0 and NFSv4.1 XDR decode functions
488 * NFSv4.0 callback result types are defined in section 15 of RFC
489 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
490 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
494 static int nfs4_xdr_dec_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
501 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
503 static int nfs4_xdr_dec_cb_recall(struct rpc_rqst
*rqstp
,
504 struct xdr_stream
*xdr
,
507 struct nfsd4_callback
*cb
= data
;
508 struct nfs4_cb_compound_hdr hdr
;
511 status
= decode_cb_compound4res(xdr
, &hdr
);
512 if (unlikely(status
))
516 status
= decode_cb_sequence4res(xdr
, cb
);
517 if (unlikely(status
|| cb
->cb_seq_status
))
521 return decode_cb_op_status(xdr
, OP_CB_RECALL
, &cb
->cb_status
);
524 #ifdef CONFIG_NFSD_PNFS
526 * CB_LAYOUTRECALL4args
528 * struct layoutrecall_file4 {
530 * offset4 lor_offset;
531 * length4 lor_length;
532 * stateid4 lor_stateid;
535 * union layoutrecall4 switch(layoutrecall_type4 lor_recalltype) {
536 * case LAYOUTRECALL4_FILE:
537 * layoutrecall_file4 lor_layout;
538 * case LAYOUTRECALL4_FSID:
540 * case LAYOUTRECALL4_ALL:
544 * struct CB_LAYOUTRECALL4args {
545 * layouttype4 clora_type;
546 * layoutiomode4 clora_iomode;
547 * bool clora_changed;
548 * layoutrecall4 clora_recall;
551 static void encode_cb_layout4args(struct xdr_stream
*xdr
,
552 const struct nfs4_layout_stateid
*ls
,
553 struct nfs4_cb_compound_hdr
*hdr
)
557 BUG_ON(hdr
->minorversion
== 0);
559 p
= xdr_reserve_space(xdr
, 5 * 4);
560 *p
++ = cpu_to_be32(OP_CB_LAYOUTRECALL
);
561 *p
++ = cpu_to_be32(ls
->ls_layout_type
);
562 *p
++ = cpu_to_be32(IOMODE_ANY
);
563 *p
++ = cpu_to_be32(1);
564 *p
= cpu_to_be32(RETURN_FILE
);
566 encode_nfs_fh4(xdr
, &ls
->ls_stid
.sc_file
->fi_fhandle
);
568 p
= xdr_reserve_space(xdr
, 2 * 8);
569 p
= xdr_encode_hyper(p
, 0);
570 xdr_encode_hyper(p
, NFS4_MAX_UINT64
);
572 encode_stateid4(xdr
, &ls
->ls_recall_sid
);
577 static void nfs4_xdr_enc_cb_layout(struct rpc_rqst
*req
,
578 struct xdr_stream
*xdr
,
581 const struct nfsd4_callback
*cb
= data
;
582 const struct nfs4_layout_stateid
*ls
=
583 container_of(cb
, struct nfs4_layout_stateid
, ls_recall
);
584 struct nfs4_cb_compound_hdr hdr
= {
586 .minorversion
= cb
->cb_clp
->cl_minorversion
,
589 encode_cb_compound4args(xdr
, &hdr
);
590 encode_cb_sequence4args(xdr
, cb
, &hdr
);
591 encode_cb_layout4args(xdr
, ls
, &hdr
);
592 encode_cb_nops(&hdr
);
595 static int nfs4_xdr_dec_cb_layout(struct rpc_rqst
*rqstp
,
596 struct xdr_stream
*xdr
,
599 struct nfsd4_callback
*cb
= data
;
600 struct nfs4_cb_compound_hdr hdr
;
603 status
= decode_cb_compound4res(xdr
, &hdr
);
604 if (unlikely(status
))
608 status
= decode_cb_sequence4res(xdr
, cb
);
609 if (unlikely(status
|| cb
->cb_seq_status
))
612 return decode_cb_op_status(xdr
, OP_CB_LAYOUTRECALL
, &cb
->cb_status
);
614 #endif /* CONFIG_NFSD_PNFS */
616 static void encode_stateowner(struct xdr_stream
*xdr
, struct nfs4_stateowner
*so
)
620 p
= xdr_reserve_space(xdr
, 8 + 4 + so
->so_owner
.len
);
621 p
= xdr_encode_opaque_fixed(p
, &so
->so_client
->cl_clientid
, 8);
622 xdr_encode_opaque(p
, so
->so_owner
.data
, so
->so_owner
.len
);
625 static void nfs4_xdr_enc_cb_notify_lock(struct rpc_rqst
*req
,
626 struct xdr_stream
*xdr
,
629 const struct nfsd4_callback
*cb
= data
;
630 const struct nfsd4_blocked_lock
*nbl
=
631 container_of(cb
, struct nfsd4_blocked_lock
, nbl_cb
);
632 struct nfs4_lockowner
*lo
= (struct nfs4_lockowner
*)nbl
->nbl_lock
.fl_owner
;
633 struct nfs4_cb_compound_hdr hdr
= {
635 .minorversion
= cb
->cb_clp
->cl_minorversion
,
640 BUG_ON(hdr
.minorversion
== 0);
642 encode_cb_compound4args(xdr
, &hdr
);
643 encode_cb_sequence4args(xdr
, cb
, &hdr
);
645 p
= xdr_reserve_space(xdr
, 4);
646 *p
= cpu_to_be32(OP_CB_NOTIFY_LOCK
);
647 encode_nfs_fh4(xdr
, &nbl
->nbl_fh
);
648 encode_stateowner(xdr
, &lo
->lo_owner
);
651 encode_cb_nops(&hdr
);
654 static int nfs4_xdr_dec_cb_notify_lock(struct rpc_rqst
*rqstp
,
655 struct xdr_stream
*xdr
,
658 struct nfsd4_callback
*cb
= data
;
659 struct nfs4_cb_compound_hdr hdr
;
662 status
= decode_cb_compound4res(xdr
, &hdr
);
663 if (unlikely(status
))
667 status
= decode_cb_sequence4res(xdr
, cb
);
668 if (unlikely(status
|| cb
->cb_seq_status
))
671 return decode_cb_op_status(xdr
, OP_CB_NOTIFY_LOCK
, &cb
->cb_status
);
675 * struct write_response4 {
676 * stateid4 wr_callback_id<1>;
678 * stable_how4 wr_committed;
679 * verifier4 wr_writeverf;
681 * union offload_info4 switch (nfsstat4 coa_status) {
683 * write_response4 coa_resok4;
685 * length4 coa_bytes_copied;
687 * struct CB_OFFLOAD4args {
689 * stateid4 coa_stateid;
690 * offload_info4 coa_offload_info;
693 static void encode_offload_info4(struct xdr_stream
*xdr
,
695 const struct nfsd4_copy
*cp
)
699 p
= xdr_reserve_space(xdr
, 4);
702 p
= xdr_reserve_space(xdr
, 4 + 8 + 4 + NFS4_VERIFIER_SIZE
);
703 p
= xdr_encode_empty_array(p
);
704 p
= xdr_encode_hyper(p
, cp
->cp_res
.wr_bytes_written
);
705 *p
++ = cpu_to_be32(cp
->cp_res
.wr_stable_how
);
706 p
= xdr_encode_opaque_fixed(p
, cp
->cp_res
.wr_verifier
.data
,
709 p
= xdr_reserve_space(xdr
, 8);
710 /* We always return success if bytes were written */
711 p
= xdr_encode_hyper(p
, 0);
715 static void encode_cb_offload4args(struct xdr_stream
*xdr
,
717 const struct knfsd_fh
*fh
,
718 const struct nfsd4_copy
*cp
,
719 struct nfs4_cb_compound_hdr
*hdr
)
723 p
= xdr_reserve_space(xdr
, 4);
724 *p
++ = cpu_to_be32(OP_CB_OFFLOAD
);
725 encode_nfs_fh4(xdr
, fh
);
726 encode_stateid4(xdr
, &cp
->cp_res
.cb_stateid
);
727 encode_offload_info4(xdr
, nfserr
, cp
);
732 static void nfs4_xdr_enc_cb_offload(struct rpc_rqst
*req
,
733 struct xdr_stream
*xdr
,
736 const struct nfsd4_callback
*cb
= data
;
737 const struct nfsd4_copy
*cp
=
738 container_of(cb
, struct nfsd4_copy
, cp_cb
);
739 struct nfs4_cb_compound_hdr hdr
= {
741 .minorversion
= cb
->cb_clp
->cl_minorversion
,
744 encode_cb_compound4args(xdr
, &hdr
);
745 encode_cb_sequence4args(xdr
, cb
, &hdr
);
746 encode_cb_offload4args(xdr
, cp
->nfserr
, &cp
->fh
, cp
, &hdr
);
747 encode_cb_nops(&hdr
);
750 static int nfs4_xdr_dec_cb_offload(struct rpc_rqst
*rqstp
,
751 struct xdr_stream
*xdr
,
754 struct nfsd4_callback
*cb
= data
;
755 struct nfs4_cb_compound_hdr hdr
;
758 status
= decode_cb_compound4res(xdr
, &hdr
);
759 if (unlikely(status
))
763 status
= decode_cb_sequence4res(xdr
, cb
);
764 if (unlikely(status
|| cb
->cb_seq_status
))
767 return decode_cb_op_status(xdr
, OP_CB_OFFLOAD
, &cb
->cb_status
);
770 * RPC procedure tables
772 #define PROC(proc, call, argtype, restype) \
773 [NFSPROC4_CLNT_##proc] = { \
774 .p_proc = NFSPROC4_CB_##call, \
775 .p_encode = nfs4_xdr_enc_##argtype, \
776 .p_decode = nfs4_xdr_dec_##restype, \
777 .p_arglen = NFS4_enc_##argtype##_sz, \
778 .p_replen = NFS4_dec_##restype##_sz, \
779 .p_statidx = NFSPROC4_CB_##call, \
783 static const struct rpc_procinfo nfs4_cb_procedures
[] = {
784 PROC(CB_NULL
, NULL
, cb_null
, cb_null
),
785 PROC(CB_RECALL
, COMPOUND
, cb_recall
, cb_recall
),
786 #ifdef CONFIG_NFSD_PNFS
787 PROC(CB_LAYOUT
, COMPOUND
, cb_layout
, cb_layout
),
789 PROC(CB_NOTIFY_LOCK
, COMPOUND
, cb_notify_lock
, cb_notify_lock
),
790 PROC(CB_OFFLOAD
, COMPOUND
, cb_offload
, cb_offload
),
793 static unsigned int nfs4_cb_counts
[ARRAY_SIZE(nfs4_cb_procedures
)];
794 static const struct rpc_version nfs_cb_version4
= {
796 * Note on the callback rpc program version number: despite language in rfc
797 * 5661 section 18.36.3 requiring servers to use 4 in this field, the
798 * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
799 * in practice that appears to be what implementations use. The section
800 * 18.36.3 language is expected to be fixed in an erratum.
803 .nrprocs
= ARRAY_SIZE(nfs4_cb_procedures
),
804 .procs
= nfs4_cb_procedures
,
805 .counts
= nfs4_cb_counts
,
808 static const struct rpc_version
*nfs_cb_version
[2] = {
809 [1] = &nfs_cb_version4
,
812 static const struct rpc_program cb_program
;
814 static struct rpc_stat cb_stats
= {
815 .program
= &cb_program
818 #define NFS4_CALLBACK 0x40000000
819 static const struct rpc_program cb_program
= {
821 .number
= NFS4_CALLBACK
,
822 .nrvers
= ARRAY_SIZE(nfs_cb_version
),
823 .version
= nfs_cb_version
,
825 .pipe_dir_name
= "nfsd4_cb",
828 static int max_cb_time(struct net
*net
)
830 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
831 return max(nn
->nfsd4_lease
/10, (time_t)1) * HZ
;
834 static const struct cred
*get_backchannel_cred(struct nfs4_client
*clp
, struct rpc_clnt
*client
, struct nfsd4_session
*ses
)
836 if (clp
->cl_minorversion
== 0) {
837 client
->cl_principal
= clp
->cl_cred
.cr_targ_princ
?
838 clp
->cl_cred
.cr_targ_princ
: "nfs";
840 return get_cred(rpc_machine_cred());
844 kcred
= prepare_kernel_cred(NULL
);
848 kcred
->uid
= ses
->se_cb_sec
.uid
;
849 kcred
->gid
= ses
->se_cb_sec
.gid
;
854 static int setup_callback_client(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
, struct nfsd4_session
*ses
)
856 int maxtime
= max_cb_time(clp
->net
);
857 struct rpc_timeout timeparms
= {
858 .to_initval
= maxtime
,
860 .to_maxval
= maxtime
,
862 struct rpc_create_args args
= {
864 .address
= (struct sockaddr
*) &conn
->cb_addr
,
865 .addrsize
= conn
->cb_addrlen
,
866 .saddress
= (struct sockaddr
*) &conn
->cb_saddr
,
867 .timeout
= &timeparms
,
868 .program
= &cb_program
,
870 .flags
= (RPC_CLNT_CREATE_NOPING
| RPC_CLNT_CREATE_QUIET
),
872 struct rpc_clnt
*client
;
873 const struct cred
*cred
;
875 if (clp
->cl_minorversion
== 0) {
876 if (!clp
->cl_cred
.cr_principal
&&
877 (clp
->cl_cred
.cr_flavor
>= RPC_AUTH_GSS_KRB5
))
879 args
.client_name
= clp
->cl_cred
.cr_principal
;
880 args
.prognumber
= conn
->cb_prog
;
881 args
.protocol
= XPRT_TRANSPORT_TCP
;
882 args
.authflavor
= clp
->cl_cred
.cr_flavor
;
883 clp
->cl_cb_ident
= conn
->cb_ident
;
887 clp
->cl_cb_conn
.cb_xprt
= conn
->cb_xprt
;
888 clp
->cl_cb_session
= ses
;
889 args
.bc_xprt
= conn
->cb_xprt
;
890 args
.prognumber
= clp
->cl_cb_session
->se_cb_prog
;
891 args
.protocol
= conn
->cb_xprt
->xpt_class
->xcl_ident
|
893 args
.authflavor
= ses
->se_cb_sec
.flavor
;
895 /* Create RPC client */
896 client
= rpc_create(&args
);
897 if (IS_ERR(client
)) {
898 dprintk("NFSD: couldn't create callback client: %ld\n",
900 return PTR_ERR(client
);
902 cred
= get_backchannel_cred(clp
, client
, ses
);
904 rpc_shutdown_client(client
);
907 clp
->cl_cb_client
= client
;
908 clp
->cl_cb_cred
= cred
;
912 static void warn_no_callback_path(struct nfs4_client
*clp
, int reason
)
914 dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
915 (int)clp
->cl_name
.len
, clp
->cl_name
.data
, reason
);
918 static void nfsd4_mark_cb_down(struct nfs4_client
*clp
, int reason
)
920 if (test_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
))
922 clp
->cl_cb_state
= NFSD4_CB_DOWN
;
923 warn_no_callback_path(clp
, reason
);
926 static void nfsd4_mark_cb_fault(struct nfs4_client
*clp
, int reason
)
928 if (test_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
))
930 clp
->cl_cb_state
= NFSD4_CB_FAULT
;
931 warn_no_callback_path(clp
, reason
);
934 static void nfsd4_cb_probe_done(struct rpc_task
*task
, void *calldata
)
936 struct nfs4_client
*clp
= container_of(calldata
, struct nfs4_client
, cl_cb_null
);
939 nfsd4_mark_cb_down(clp
, task
->tk_status
);
941 clp
->cl_cb_state
= NFSD4_CB_UP
;
944 static const struct rpc_call_ops nfsd4_cb_probe_ops
= {
945 /* XXX: release method to ensure we set the cb channel down if
946 * necessary on early failure? */
947 .rpc_call_done
= nfsd4_cb_probe_done
,
950 static struct workqueue_struct
*callback_wq
;
953 * Poke the callback thread to process any updates to the callback
954 * parameters, and send a null probe.
956 void nfsd4_probe_callback(struct nfs4_client
*clp
)
958 clp
->cl_cb_state
= NFSD4_CB_UNKNOWN
;
959 set_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
);
960 nfsd4_run_cb(&clp
->cl_cb_null
);
963 void nfsd4_probe_callback_sync(struct nfs4_client
*clp
)
965 nfsd4_probe_callback(clp
);
966 flush_workqueue(callback_wq
);
969 void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
971 clp
->cl_cb_state
= NFSD4_CB_UNKNOWN
;
972 spin_lock(&clp
->cl_lock
);
973 memcpy(&clp
->cl_cb_conn
, conn
, sizeof(struct nfs4_cb_conn
));
974 spin_unlock(&clp
->cl_lock
);
978 * There's currently a single callback channel slot.
979 * If the slot is available, then mark it busy. Otherwise, set the
980 * thread for sleeping on the callback RPC wait queue.
982 static bool nfsd41_cb_get_slot(struct nfs4_client
*clp
, struct rpc_task
*task
)
984 if (test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
985 rpc_sleep_on(&clp
->cl_cb_waitq
, task
, NULL
);
987 if (test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
988 dprintk("%s slot is busy\n", __func__
);
991 rpc_wake_up_queued_task(&clp
->cl_cb_waitq
, task
);
997 * TODO: cb_sequence should support referring call lists, cachethis, multiple
998 * slots, and mark callback channel down on communication errors.
1000 static void nfsd4_cb_prepare(struct rpc_task
*task
, void *calldata
)
1002 struct nfsd4_callback
*cb
= calldata
;
1003 struct nfs4_client
*clp
= cb
->cb_clp
;
1004 u32 minorversion
= clp
->cl_minorversion
;
1007 * cb_seq_status is only set in decode_cb_sequence4res,
1008 * and so will remain 1 if an rpc level failure occurs.
1010 cb
->cb_seq_status
= 1;
1013 if (!cb
->cb_holds_slot
&& !nfsd41_cb_get_slot(clp
, task
))
1015 cb
->cb_holds_slot
= true;
1017 rpc_call_start(task
);
1020 static bool nfsd4_cb_sequence_done(struct rpc_task
*task
, struct nfsd4_callback
*cb
)
1022 struct nfs4_client
*clp
= cb
->cb_clp
;
1023 struct nfsd4_session
*session
= clp
->cl_cb_session
;
1026 if (!clp
->cl_minorversion
) {
1028 * If the backchannel connection was shut down while this
1029 * task was queued, we need to resubmit it after setting up
1030 * a new backchannel connection.
1032 * Note that if we lost our callback connection permanently
1033 * the submission code will error out, so we don't need to
1034 * handle that case here.
1036 if (task
->tk_flags
& RPC_TASK_KILLED
)
1042 if (!cb
->cb_holds_slot
)
1045 switch (cb
->cb_seq_status
) {
1048 * No need for lock, access serialized in nfsd4_cb_prepare
1051 * If CB_SEQUENCE returns an error, then the state of the slot
1052 * (sequence ID, cached reply) MUST NOT change.
1054 ++session
->se_cb_seq_nr
;
1057 ++session
->se_cb_seq_nr
;
1060 case -NFS4ERR_BADSESSION
:
1061 nfsd4_mark_cb_fault(cb
->cb_clp
, cb
->cb_seq_status
);
1064 case -NFS4ERR_DELAY
:
1065 if (!rpc_restart_call(task
))
1068 rpc_delay(task
, 2 * HZ
);
1070 case -NFS4ERR_BADSLOT
:
1072 case -NFS4ERR_SEQ_MISORDERED
:
1073 if (session
->se_cb_seq_nr
!= 1) {
1074 session
->se_cb_seq_nr
= 1;
1079 dprintk("%s: unprocessed error %d\n", __func__
,
1083 cb
->cb_holds_slot
= false;
1084 clear_bit(0, &clp
->cl_cb_slot_busy
);
1085 rpc_wake_up_next(&clp
->cl_cb_waitq
);
1086 dprintk("%s: freed slot, new seqid=%d\n", __func__
,
1087 clp
->cl_cb_session
->se_cb_seq_nr
);
1089 if (task
->tk_flags
& RPC_TASK_KILLED
)
1094 if (rpc_restart_call_prepare(task
))
1098 task
->tk_status
= 0;
1099 cb
->cb_need_restart
= true;
1103 static void nfsd4_cb_done(struct rpc_task
*task
, void *calldata
)
1105 struct nfsd4_callback
*cb
= calldata
;
1106 struct nfs4_client
*clp
= cb
->cb_clp
;
1108 dprintk("%s: minorversion=%d\n", __func__
,
1109 clp
->cl_minorversion
);
1111 if (!nfsd4_cb_sequence_done(task
, cb
))
1114 if (cb
->cb_status
) {
1115 WARN_ON_ONCE(task
->tk_status
);
1116 task
->tk_status
= cb
->cb_status
;
1119 switch (cb
->cb_ops
->done(cb
, task
)) {
1121 task
->tk_status
= 0;
1122 rpc_restart_call_prepare(task
);
1127 /* Network partition? */
1128 nfsd4_mark_cb_down(clp
, task
->tk_status
);
1135 static void nfsd4_cb_release(void *calldata
)
1137 struct nfsd4_callback
*cb
= calldata
;
1139 if (cb
->cb_need_restart
)
1142 cb
->cb_ops
->release(cb
);
1146 static const struct rpc_call_ops nfsd4_cb_ops
= {
1147 .rpc_call_prepare
= nfsd4_cb_prepare
,
1148 .rpc_call_done
= nfsd4_cb_done
,
1149 .rpc_release
= nfsd4_cb_release
,
1152 int nfsd4_create_callback_queue(void)
1154 callback_wq
= alloc_ordered_workqueue("nfsd4_callbacks", 0);
1160 void nfsd4_destroy_callback_queue(void)
1162 destroy_workqueue(callback_wq
);
1165 /* must be called under the state lock */
1166 void nfsd4_shutdown_callback(struct nfs4_client
*clp
)
1168 set_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
);
1170 * Note this won't actually result in a null callback;
1171 * instead, nfsd4_run_cb_null() will detect the killed
1172 * client, destroy the rpc client, and stop:
1174 nfsd4_run_cb(&clp
->cl_cb_null
);
1175 flush_workqueue(callback_wq
);
1178 /* requires cl_lock: */
1179 static struct nfsd4_conn
* __nfsd4_find_backchannel(struct nfs4_client
*clp
)
1181 struct nfsd4_session
*s
;
1182 struct nfsd4_conn
*c
;
1184 list_for_each_entry(s
, &clp
->cl_sessions
, se_perclnt
) {
1185 list_for_each_entry(c
, &s
->se_conns
, cn_persession
) {
1186 if (c
->cn_flags
& NFS4_CDFC4_BACK
)
1193 static void nfsd4_process_cb_update(struct nfsd4_callback
*cb
)
1195 struct nfs4_cb_conn conn
;
1196 struct nfs4_client
*clp
= cb
->cb_clp
;
1197 struct nfsd4_session
*ses
= NULL
;
1198 struct nfsd4_conn
*c
;
1202 * This is either an update, or the client dying; in either case,
1203 * kill the old client:
1205 if (clp
->cl_cb_client
) {
1206 rpc_shutdown_client(clp
->cl_cb_client
);
1207 clp
->cl_cb_client
= NULL
;
1208 put_cred(clp
->cl_cb_cred
);
1209 clp
->cl_cb_cred
= NULL
;
1211 if (clp
->cl_cb_conn
.cb_xprt
) {
1212 svc_xprt_put(clp
->cl_cb_conn
.cb_xprt
);
1213 clp
->cl_cb_conn
.cb_xprt
= NULL
;
1215 if (test_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
))
1217 spin_lock(&clp
->cl_lock
);
1219 * Only serialized callback code is allowed to clear these
1220 * flags; main nfsd code can only set them:
1222 BUG_ON(!(clp
->cl_flags
& NFSD4_CLIENT_CB_FLAG_MASK
));
1223 clear_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
);
1224 memcpy(&conn
, &cb
->cb_clp
->cl_cb_conn
, sizeof(struct nfs4_cb_conn
));
1225 c
= __nfsd4_find_backchannel(clp
);
1227 svc_xprt_get(c
->cn_xprt
);
1228 conn
.cb_xprt
= c
->cn_xprt
;
1229 ses
= c
->cn_session
;
1231 spin_unlock(&clp
->cl_lock
);
1233 err
= setup_callback_client(clp
, &conn
, ses
);
1235 nfsd4_mark_cb_down(clp
, err
);
1241 nfsd4_run_cb_work(struct work_struct
*work
)
1243 struct nfsd4_callback
*cb
=
1244 container_of(work
, struct nfsd4_callback
, cb_work
);
1245 struct nfs4_client
*clp
= cb
->cb_clp
;
1246 struct rpc_clnt
*clnt
;
1248 if (cb
->cb_need_restart
) {
1249 cb
->cb_need_restart
= false;
1251 if (cb
->cb_ops
&& cb
->cb_ops
->prepare
)
1252 cb
->cb_ops
->prepare(cb
);
1255 if (clp
->cl_flags
& NFSD4_CLIENT_CB_FLAG_MASK
)
1256 nfsd4_process_cb_update(cb
);
1258 clnt
= clp
->cl_cb_client
;
1260 /* Callback channel broken, or client killed; give up: */
1261 if (cb
->cb_ops
&& cb
->cb_ops
->release
)
1262 cb
->cb_ops
->release(cb
);
1267 * Don't send probe messages for 4.1 or later.
1269 if (!cb
->cb_ops
&& clp
->cl_minorversion
) {
1270 clp
->cl_cb_state
= NFSD4_CB_UP
;
1274 cb
->cb_msg
.rpc_cred
= clp
->cl_cb_cred
;
1275 rpc_call_async(clnt
, &cb
->cb_msg
, RPC_TASK_SOFT
| RPC_TASK_SOFTCONN
,
1276 cb
->cb_ops
? &nfsd4_cb_ops
: &nfsd4_cb_probe_ops
, cb
);
1279 void nfsd4_init_cb(struct nfsd4_callback
*cb
, struct nfs4_client
*clp
,
1280 const struct nfsd4_callback_ops
*ops
, enum nfsd4_cb_op op
)
1283 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[op
];
1284 cb
->cb_msg
.rpc_argp
= cb
;
1285 cb
->cb_msg
.rpc_resp
= cb
;
1287 INIT_WORK(&cb
->cb_work
, nfsd4_run_cb_work
);
1288 cb
->cb_seq_status
= 1;
1290 cb
->cb_need_restart
= false;
1291 cb
->cb_holds_slot
= false;
1294 void nfsd4_run_cb(struct nfsd4_callback
*cb
)
1296 queue_work(callback_wq
, &cb
->cb_work
);