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/svc_xprt.h>
36 #include <linux/slab.h>
42 #define NFSDDBG_FACILITY NFSDDBG_PROC
44 static void nfsd4_mark_cb_fault(struct nfs4_client
*, int reason
);
46 #define NFSPROC4_CB_NULL 0
47 #define NFSPROC4_CB_COMPOUND 1
49 /* Index of predefined Linux callback client operations */
52 NFSPROC4_CLNT_CB_NULL
= 0,
53 NFSPROC4_CLNT_CB_RECALL
,
54 NFSPROC4_CLNT_CB_SEQUENCE
,
57 struct nfs4_cb_compound_hdr
{
59 u32 ident
; /* minorversion 0 only */
68 * Handle decode buffer overflows out-of-line.
70 static void print_overflow_msg(const char *func
, const struct xdr_stream
*xdr
)
72 dprintk("NFS: %s prematurely hit the end of our receive buffer. "
73 "Remaining buffer length is %tu words.\n",
74 func
, xdr
->end
- xdr
->p
);
77 static __be32
*xdr_encode_empty_array(__be32
*p
)
84 * Encode/decode NFSv4 CB basic data types
86 * Basic NFSv4 callback data types are defined in section 15 of RFC
87 * 3530: "Network File System (NFS) version 4 Protocol" and section
88 * 20 of RFC 5661: "Network File System (NFS) Version 4 Minor Version
95 * enum nfs_cb_opnum4 {
103 OP_CB_LAYOUTRECALL
= 5,
105 OP_CB_PUSH_DELEG
= 7,
106 OP_CB_RECALL_ANY
= 8,
107 OP_CB_RECALLABLE_OBJ_AVAIL
= 9,
108 OP_CB_RECALL_SLOT
= 10,
110 OP_CB_WANTS_CANCELLED
= 12,
111 OP_CB_NOTIFY_LOCK
= 13,
112 OP_CB_NOTIFY_DEVICEID
= 14,
113 OP_CB_ILLEGAL
= 10044
116 static void encode_nfs_cb_opnum4(struct xdr_stream
*xdr
, enum nfs_cb_opnum4 op
)
120 p
= xdr_reserve_space(xdr
, 4);
121 *p
= cpu_to_be32(op
);
127 * typedef opaque nfs_fh4<NFS4_FHSIZE>;
129 static void encode_nfs_fh4(struct xdr_stream
*xdr
, const struct knfsd_fh
*fh
)
131 u32 length
= fh
->fh_size
;
134 BUG_ON(length
> NFS4_FHSIZE
);
135 p
= xdr_reserve_space(xdr
, 4 + length
);
136 xdr_encode_opaque(p
, &fh
->fh_base
, length
);
147 static void encode_stateid4(struct xdr_stream
*xdr
, const stateid_t
*sid
)
151 p
= xdr_reserve_space(xdr
, NFS4_STATEID_SIZE
);
152 *p
++ = cpu_to_be32(sid
->si_generation
);
153 xdr_encode_opaque_fixed(p
, &sid
->si_opaque
, NFS4_STATEID_OTHER_SIZE
);
159 * typedef opaque sessionid4[NFS4_SESSIONID_SIZE];
161 static void encode_sessionid4(struct xdr_stream
*xdr
,
162 const struct nfsd4_session
*session
)
166 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
);
167 xdr_encode_opaque_fixed(p
, session
->se_sessionid
.data
,
168 NFS4_MAX_SESSIONID_LEN
);
174 static const struct {
177 } nfs_cb_errtbl
[] = {
179 { NFS4ERR_PERM
, -EPERM
},
180 { NFS4ERR_NOENT
, -ENOENT
},
181 { NFS4ERR_IO
, -EIO
},
182 { NFS4ERR_NXIO
, -ENXIO
},
183 { NFS4ERR_ACCESS
, -EACCES
},
184 { NFS4ERR_EXIST
, -EEXIST
},
185 { NFS4ERR_XDEV
, -EXDEV
},
186 { NFS4ERR_NOTDIR
, -ENOTDIR
},
187 { NFS4ERR_ISDIR
, -EISDIR
},
188 { NFS4ERR_INVAL
, -EINVAL
},
189 { NFS4ERR_FBIG
, -EFBIG
},
190 { NFS4ERR_NOSPC
, -ENOSPC
},
191 { NFS4ERR_ROFS
, -EROFS
},
192 { NFS4ERR_MLINK
, -EMLINK
},
193 { NFS4ERR_NAMETOOLONG
, -ENAMETOOLONG
},
194 { NFS4ERR_NOTEMPTY
, -ENOTEMPTY
},
195 { NFS4ERR_DQUOT
, -EDQUOT
},
196 { NFS4ERR_STALE
, -ESTALE
},
197 { NFS4ERR_BADHANDLE
, -EBADHANDLE
},
198 { NFS4ERR_BAD_COOKIE
, -EBADCOOKIE
},
199 { NFS4ERR_NOTSUPP
, -ENOTSUPP
},
200 { NFS4ERR_TOOSMALL
, -ETOOSMALL
},
201 { NFS4ERR_SERVERFAULT
, -ESERVERFAULT
},
202 { NFS4ERR_BADTYPE
, -EBADTYPE
},
203 { NFS4ERR_LOCKED
, -EAGAIN
},
204 { NFS4ERR_RESOURCE
, -EREMOTEIO
},
205 { NFS4ERR_SYMLINK
, -ELOOP
},
206 { NFS4ERR_OP_ILLEGAL
, -EOPNOTSUPP
},
207 { NFS4ERR_DEADLOCK
, -EDEADLK
},
212 * If we cannot translate the error, the recovery routines should
215 * Note: remaining NFSv4 error codes have values > 10000, so should
216 * not conflict with native Linux error codes.
218 static int nfs_cb_stat_to_errno(int status
)
222 for (i
= 0; nfs_cb_errtbl
[i
].stat
!= -1; i
++) {
223 if (nfs_cb_errtbl
[i
].stat
== status
)
224 return nfs_cb_errtbl
[i
].errno
;
227 dprintk("NFSD: Unrecognized NFS CB status value: %u\n", status
);
231 static int decode_cb_op_status(struct xdr_stream
*xdr
, enum nfs_opnum4 expected
,
232 enum nfsstat4
*status
)
237 p
= xdr_inline_decode(xdr
, 4 + 4);
238 if (unlikely(p
== NULL
))
240 op
= be32_to_cpup(p
++);
241 if (unlikely(op
!= expected
))
243 *status
= be32_to_cpup(p
);
246 print_overflow_msg(__func__
, xdr
);
249 dprintk("NFSD: Callback server returned operation %d but "
250 "we issued a request for %d\n", op
, expected
);
257 * struct CB_COMPOUND4args {
259 * uint32_t minorversion;
260 * uint32_t callback_ident;
261 * nfs_cb_argop4 argarray<>;
264 static void encode_cb_compound4args(struct xdr_stream
*xdr
,
265 struct nfs4_cb_compound_hdr
*hdr
)
269 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4);
270 p
= xdr_encode_empty_array(p
); /* empty tag */
271 *p
++ = cpu_to_be32(hdr
->minorversion
);
272 *p
++ = cpu_to_be32(hdr
->ident
);
275 *p
= cpu_to_be32(hdr
->nops
); /* argarray element count */
279 * Update argarray element count
281 static void encode_cb_nops(struct nfs4_cb_compound_hdr
*hdr
)
283 BUG_ON(hdr
->nops
> NFS4_MAX_BACK_CHANNEL_OPS
);
284 *hdr
->nops_p
= cpu_to_be32(hdr
->nops
);
290 * struct CB_COMPOUND4res {
293 * nfs_cb_resop4 resarray<>;
296 static int decode_cb_compound4res(struct xdr_stream
*xdr
,
297 struct nfs4_cb_compound_hdr
*hdr
)
302 p
= xdr_inline_decode(xdr
, 4 + 4);
303 if (unlikely(p
== NULL
))
305 hdr
->status
= be32_to_cpup(p
++);
307 length
= be32_to_cpup(p
++);
308 p
= xdr_inline_decode(xdr
, length
+ 4);
309 if (unlikely(p
== NULL
))
311 hdr
->nops
= be32_to_cpup(p
);
314 print_overflow_msg(__func__
, xdr
);
321 * struct CB_RECALL4args {
327 static void encode_cb_recall4args(struct xdr_stream
*xdr
,
328 const struct nfs4_delegation
*dp
,
329 struct nfs4_cb_compound_hdr
*hdr
)
333 encode_nfs_cb_opnum4(xdr
, OP_CB_RECALL
);
334 encode_stateid4(xdr
, &dp
->dl_stid
.sc_stateid
);
336 p
= xdr_reserve_space(xdr
, 4);
337 *p
++ = xdr_zero
; /* truncate */
339 encode_nfs_fh4(xdr
, &dp
->dl_fh
);
347 * struct CB_SEQUENCE4args {
348 * sessionid4 csa_sessionid;
349 * sequenceid4 csa_sequenceid;
350 * slotid4 csa_slotid;
351 * slotid4 csa_highest_slotid;
352 * bool csa_cachethis;
353 * referring_call_list4 csa_referring_call_lists<>;
356 static void encode_cb_sequence4args(struct xdr_stream
*xdr
,
357 const struct nfsd4_callback
*cb
,
358 struct nfs4_cb_compound_hdr
*hdr
)
360 struct nfsd4_session
*session
= cb
->cb_clp
->cl_cb_session
;
363 if (hdr
->minorversion
== 0)
366 encode_nfs_cb_opnum4(xdr
, OP_CB_SEQUENCE
);
367 encode_sessionid4(xdr
, session
);
369 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4 + 4);
370 *p
++ = cpu_to_be32(session
->se_cb_seq_nr
); /* csa_sequenceid */
371 *p
++ = xdr_zero
; /* csa_slotid */
372 *p
++ = xdr_zero
; /* csa_highest_slotid */
373 *p
++ = xdr_zero
; /* csa_cachethis */
374 xdr_encode_empty_array(p
); /* csa_referring_call_lists */
382 * struct CB_SEQUENCE4resok {
383 * sessionid4 csr_sessionid;
384 * sequenceid4 csr_sequenceid;
385 * slotid4 csr_slotid;
386 * slotid4 csr_highest_slotid;
387 * slotid4 csr_target_highest_slotid;
390 * union CB_SEQUENCE4res switch (nfsstat4 csr_status) {
392 * CB_SEQUENCE4resok csr_resok4;
397 * Our current back channel implmentation supports a single backchannel
398 * with a single slot.
400 static int decode_cb_sequence4resok(struct xdr_stream
*xdr
,
401 struct nfsd4_callback
*cb
)
403 struct nfsd4_session
*session
= cb
->cb_clp
->cl_cb_session
;
404 struct nfs4_sessionid id
;
409 status
= -ESERVERFAULT
;
412 * If the server returns different values for sessionID, slotID or
413 * sequence number, the server is looney tunes.
415 p
= xdr_inline_decode(xdr
, NFS4_MAX_SESSIONID_LEN
+ 4 + 4 + 4 + 4);
416 if (unlikely(p
== NULL
))
418 memcpy(id
.data
, p
, NFS4_MAX_SESSIONID_LEN
);
419 if (memcmp(id
.data
, session
->se_sessionid
.data
,
420 NFS4_MAX_SESSIONID_LEN
) != 0) {
421 dprintk("NFS: %s Invalid session id\n", __func__
);
424 p
+= XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN
);
426 dummy
= be32_to_cpup(p
++);
427 if (dummy
!= session
->se_cb_seq_nr
) {
428 dprintk("NFS: %s Invalid sequence number\n", __func__
);
432 dummy
= be32_to_cpup(p
++);
434 dprintk("NFS: %s Invalid slotid\n", __func__
);
439 * FIXME: process highest slotid and target highest slotid
444 nfsd4_mark_cb_fault(cb
->cb_clp
, status
);
447 print_overflow_msg(__func__
, xdr
);
451 static int decode_cb_sequence4res(struct xdr_stream
*xdr
,
452 struct nfsd4_callback
*cb
)
454 enum nfsstat4 nfserr
;
457 if (cb
->cb_minorversion
== 0)
460 status
= decode_cb_op_status(xdr
, OP_CB_SEQUENCE
, &nfserr
);
461 if (unlikely(status
))
463 if (unlikely(nfserr
!= NFS4_OK
))
465 status
= decode_cb_sequence4resok(xdr
, cb
);
469 return nfs_cb_stat_to_errno(nfserr
);
473 * NFSv4.0 and NFSv4.1 XDR encode functions
475 * NFSv4.0 callback argument types are defined in section 15 of RFC
476 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
477 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
482 * NB: Without this zero space reservation, callbacks over krb5p fail
484 static void nfs4_xdr_enc_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
487 xdr_reserve_space(xdr
, 0);
491 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
493 static void nfs4_xdr_enc_cb_recall(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
494 const struct nfsd4_callback
*cb
)
496 const struct nfs4_delegation
*args
= cb
->cb_op
;
497 struct nfs4_cb_compound_hdr hdr
= {
498 .ident
= cb
->cb_clp
->cl_cb_ident
,
499 .minorversion
= cb
->cb_minorversion
,
502 encode_cb_compound4args(xdr
, &hdr
);
503 encode_cb_sequence4args(xdr
, cb
, &hdr
);
504 encode_cb_recall4args(xdr
, args
, &hdr
);
505 encode_cb_nops(&hdr
);
510 * NFSv4.0 and NFSv4.1 XDR decode functions
512 * NFSv4.0 callback result types are defined in section 15 of RFC
513 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
514 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
518 static int nfs4_xdr_dec_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
525 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
527 static int nfs4_xdr_dec_cb_recall(struct rpc_rqst
*rqstp
,
528 struct xdr_stream
*xdr
,
529 struct nfsd4_callback
*cb
)
531 struct nfs4_cb_compound_hdr hdr
;
532 enum nfsstat4 nfserr
;
535 status
= decode_cb_compound4res(xdr
, &hdr
);
536 if (unlikely(status
))
540 status
= decode_cb_sequence4res(xdr
, cb
);
541 if (unlikely(status
))
545 status
= decode_cb_op_status(xdr
, OP_CB_RECALL
, &nfserr
);
546 if (unlikely(status
))
548 if (unlikely(nfserr
!= NFS4_OK
))
549 status
= nfs_cb_stat_to_errno(nfserr
);
555 * RPC procedure tables
557 #define PROC(proc, call, argtype, restype) \
558 [NFSPROC4_CLNT_##proc] = { \
559 .p_proc = NFSPROC4_CB_##call, \
560 .p_encode = (kxdreproc_t)nfs4_xdr_enc_##argtype, \
561 .p_decode = (kxdrdproc_t)nfs4_xdr_dec_##restype, \
562 .p_arglen = NFS4_enc_##argtype##_sz, \
563 .p_replen = NFS4_dec_##restype##_sz, \
564 .p_statidx = NFSPROC4_CB_##call, \
568 static struct rpc_procinfo nfs4_cb_procedures
[] = {
569 PROC(CB_NULL
, NULL
, cb_null
, cb_null
),
570 PROC(CB_RECALL
, COMPOUND
, cb_recall
, cb_recall
),
573 static struct rpc_version nfs_cb_version4
= {
575 * Note on the callback rpc program version number: despite language in rfc
576 * 5661 section 18.36.3 requiring servers to use 4 in this field, the
577 * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
578 * in practice that appears to be what implementations use. The section
579 * 18.36.3 language is expected to be fixed in an erratum.
582 .nrprocs
= ARRAY_SIZE(nfs4_cb_procedures
),
583 .procs
= nfs4_cb_procedures
586 static const struct rpc_version
*nfs_cb_version
[] = {
590 static const struct rpc_program cb_program
;
592 static struct rpc_stat cb_stats
= {
593 .program
= &cb_program
596 #define NFS4_CALLBACK 0x40000000
597 static const struct rpc_program cb_program
= {
599 .number
= NFS4_CALLBACK
,
600 .nrvers
= ARRAY_SIZE(nfs_cb_version
),
601 .version
= nfs_cb_version
,
603 .pipe_dir_name
= "nfsd4_cb",
606 static int max_cb_time(struct net
*net
)
608 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
609 return max(nn
->nfsd4_lease
/10, (time_t)1) * HZ
;
612 static struct rpc_cred
*callback_cred
;
614 int set_callback_cred(void)
618 callback_cred
= rpc_lookup_machine_cred("nfs");
624 static struct rpc_cred
*get_backchannel_cred(struct nfs4_client
*clp
, struct rpc_clnt
*client
, struct nfsd4_session
*ses
)
626 if (clp
->cl_minorversion
== 0) {
627 return get_rpccred(callback_cred
);
629 struct rpc_auth
*auth
= client
->cl_auth
;
630 struct auth_cred acred
= {};
632 acred
.uid
= ses
->se_cb_sec
.uid
;
633 acred
.gid
= ses
->se_cb_sec
.gid
;
634 return auth
->au_ops
->lookup_cred(client
->cl_auth
, &acred
, 0);
638 static int setup_callback_client(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
, struct nfsd4_session
*ses
)
640 int maxtime
= max_cb_time(clp
->net
);
641 struct rpc_timeout timeparms
= {
642 .to_initval
= maxtime
,
644 .to_maxval
= maxtime
,
646 struct rpc_create_args args
= {
648 .address
= (struct sockaddr
*) &conn
->cb_addr
,
649 .addrsize
= conn
->cb_addrlen
,
650 .saddress
= (struct sockaddr
*) &conn
->cb_saddr
,
651 .timeout
= &timeparms
,
652 .program
= &cb_program
,
654 .flags
= (RPC_CLNT_CREATE_NOPING
| RPC_CLNT_CREATE_QUIET
),
656 struct rpc_clnt
*client
;
657 struct rpc_cred
*cred
;
659 if (clp
->cl_minorversion
== 0) {
660 if (!clp
->cl_cred
.cr_principal
&&
661 (clp
->cl_cred
.cr_flavor
>= RPC_AUTH_GSS_KRB5
))
663 args
.client_name
= clp
->cl_cred
.cr_principal
;
664 args
.prognumber
= conn
->cb_prog
,
665 args
.protocol
= XPRT_TRANSPORT_TCP
;
666 args
.authflavor
= clp
->cl_cred
.cr_flavor
;
667 clp
->cl_cb_ident
= conn
->cb_ident
;
671 clp
->cl_cb_conn
.cb_xprt
= conn
->cb_xprt
;
672 clp
->cl_cb_session
= ses
;
673 args
.bc_xprt
= conn
->cb_xprt
;
674 args
.prognumber
= clp
->cl_cb_session
->se_cb_prog
;
675 args
.protocol
= XPRT_TRANSPORT_BC_TCP
;
676 args
.authflavor
= ses
->se_cb_sec
.flavor
;
678 /* Create RPC client */
679 client
= rpc_create(&args
);
680 if (IS_ERR(client
)) {
681 dprintk("NFSD: couldn't create callback client: %ld\n",
683 return PTR_ERR(client
);
685 cred
= get_backchannel_cred(clp
, client
, ses
);
687 rpc_shutdown_client(client
);
688 return PTR_ERR(cred
);
690 clp
->cl_cb_client
= client
;
691 clp
->cl_cb_cred
= cred
;
695 static void warn_no_callback_path(struct nfs4_client
*clp
, int reason
)
697 dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
698 (int)clp
->cl_name
.len
, clp
->cl_name
.data
, reason
);
701 static void nfsd4_mark_cb_down(struct nfs4_client
*clp
, int reason
)
703 clp
->cl_cb_state
= NFSD4_CB_DOWN
;
704 warn_no_callback_path(clp
, reason
);
707 static void nfsd4_mark_cb_fault(struct nfs4_client
*clp
, int reason
)
709 clp
->cl_cb_state
= NFSD4_CB_FAULT
;
710 warn_no_callback_path(clp
, reason
);
713 static void nfsd4_cb_probe_done(struct rpc_task
*task
, void *calldata
)
715 struct nfs4_client
*clp
= container_of(calldata
, struct nfs4_client
, cl_cb_null
);
718 nfsd4_mark_cb_down(clp
, task
->tk_status
);
720 clp
->cl_cb_state
= NFSD4_CB_UP
;
723 static const struct rpc_call_ops nfsd4_cb_probe_ops
= {
724 /* XXX: release method to ensure we set the cb channel down if
725 * necessary on early failure? */
726 .rpc_call_done
= nfsd4_cb_probe_done
,
729 static struct workqueue_struct
*callback_wq
;
731 static void run_nfsd4_cb(struct nfsd4_callback
*cb
)
733 queue_work(callback_wq
, &cb
->cb_work
);
736 static void do_probe_callback(struct nfs4_client
*clp
)
738 struct nfsd4_callback
*cb
= &clp
->cl_cb_null
;
743 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_NULL
];
744 cb
->cb_msg
.rpc_argp
= NULL
;
745 cb
->cb_msg
.rpc_resp
= NULL
;
747 cb
->cb_ops
= &nfsd4_cb_probe_ops
;
753 * Poke the callback thread to process any updates to the callback
754 * parameters, and send a null probe.
756 void nfsd4_probe_callback(struct nfs4_client
*clp
)
758 clp
->cl_cb_state
= NFSD4_CB_UNKNOWN
;
759 set_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
);
760 do_probe_callback(clp
);
763 void nfsd4_probe_callback_sync(struct nfs4_client
*clp
)
765 nfsd4_probe_callback(clp
);
766 flush_workqueue(callback_wq
);
769 void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
771 clp
->cl_cb_state
= NFSD4_CB_UNKNOWN
;
772 spin_lock(&clp
->cl_lock
);
773 memcpy(&clp
->cl_cb_conn
, conn
, sizeof(struct nfs4_cb_conn
));
774 spin_unlock(&clp
->cl_lock
);
778 * There's currently a single callback channel slot.
779 * If the slot is available, then mark it busy. Otherwise, set the
780 * thread for sleeping on the callback RPC wait queue.
782 static bool nfsd41_cb_get_slot(struct nfs4_client
*clp
, struct rpc_task
*task
)
784 if (test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
785 rpc_sleep_on(&clp
->cl_cb_waitq
, task
, NULL
);
786 dprintk("%s slot is busy\n", __func__
);
793 * TODO: cb_sequence should support referring call lists, cachethis, multiple
794 * slots, and mark callback channel down on communication errors.
796 static void nfsd4_cb_prepare(struct rpc_task
*task
, void *calldata
)
798 struct nfsd4_callback
*cb
= calldata
;
799 struct nfs4_client
*clp
= cb
->cb_clp
;
800 u32 minorversion
= clp
->cl_minorversion
;
802 cb
->cb_minorversion
= minorversion
;
804 if (!nfsd41_cb_get_slot(clp
, task
))
807 spin_lock(&clp
->cl_lock
);
808 if (list_empty(&cb
->cb_per_client
)) {
809 /* This is the first call, not a restart */
811 list_add(&cb
->cb_per_client
, &clp
->cl_callbacks
);
813 spin_unlock(&clp
->cl_lock
);
814 rpc_call_start(task
);
817 static void nfsd4_cb_done(struct rpc_task
*task
, void *calldata
)
819 struct nfsd4_callback
*cb
= calldata
;
820 struct nfs4_client
*clp
= cb
->cb_clp
;
822 dprintk("%s: minorversion=%d\n", __func__
,
823 clp
->cl_minorversion
);
825 if (clp
->cl_minorversion
) {
826 /* No need for lock, access serialized in nfsd4_cb_prepare */
827 ++clp
->cl_cb_session
->se_cb_seq_nr
;
828 clear_bit(0, &clp
->cl_cb_slot_busy
);
829 rpc_wake_up_next(&clp
->cl_cb_waitq
);
830 dprintk("%s: freed slot, new seqid=%d\n", __func__
,
831 clp
->cl_cb_session
->se_cb_seq_nr
);
833 /* We're done looking into the sequence information */
834 task
->tk_msg
.rpc_resp
= NULL
;
839 static void nfsd4_cb_recall_done(struct rpc_task
*task
, void *calldata
)
841 struct nfsd4_callback
*cb
= calldata
;
842 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
843 struct nfs4_client
*clp
= cb
->cb_clp
;
844 struct rpc_clnt
*current_rpc_client
= clp
->cl_cb_client
;
846 nfsd4_cb_done(task
, calldata
);
848 if (current_rpc_client
!= task
->tk_client
) {
849 /* We're shutting down or changing cl_cb_client; leave
850 * it to nfsd4_process_cb_update to restart the call if
857 switch (task
->tk_status
) {
862 case -NFS4ERR_BAD_STATEID
:
863 /* Race: client probably got cb_recall
864 * before open reply granting delegation */
867 /* Network partition? */
868 nfsd4_mark_cb_down(clp
, task
->tk_status
);
870 if (dp
->dl_retries
--) {
871 rpc_delay(task
, 2*HZ
);
873 rpc_restart_call_prepare(task
);
876 nfsd4_mark_cb_down(clp
, task
->tk_status
);
880 static void nfsd4_cb_recall_release(void *calldata
)
882 struct nfsd4_callback
*cb
= calldata
;
883 struct nfs4_client
*clp
= cb
->cb_clp
;
884 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
887 spin_lock(&clp
->cl_lock
);
888 list_del(&cb
->cb_per_client
);
889 spin_unlock(&clp
->cl_lock
);
890 nfs4_put_delegation(dp
);
894 static const struct rpc_call_ops nfsd4_cb_recall_ops
= {
895 .rpc_call_prepare
= nfsd4_cb_prepare
,
896 .rpc_call_done
= nfsd4_cb_recall_done
,
897 .rpc_release
= nfsd4_cb_recall_release
,
900 int nfsd4_create_callback_queue(void)
902 callback_wq
= create_singlethread_workqueue("nfsd4_callbacks");
908 void nfsd4_destroy_callback_queue(void)
910 destroy_workqueue(callback_wq
);
913 /* must be called under the state lock */
914 void nfsd4_shutdown_callback(struct nfs4_client
*clp
)
916 set_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
);
918 * Note this won't actually result in a null callback;
919 * instead, nfsd4_do_callback_rpc() will detect the killed
920 * client, destroy the rpc client, and stop:
922 do_probe_callback(clp
);
923 flush_workqueue(callback_wq
);
926 static void nfsd4_release_cb(struct nfsd4_callback
*cb
)
928 if (cb
->cb_ops
->rpc_release
)
929 cb
->cb_ops
->rpc_release(cb
);
932 /* requires cl_lock: */
933 static struct nfsd4_conn
* __nfsd4_find_backchannel(struct nfs4_client
*clp
)
935 struct nfsd4_session
*s
;
936 struct nfsd4_conn
*c
;
938 list_for_each_entry(s
, &clp
->cl_sessions
, se_perclnt
) {
939 list_for_each_entry(c
, &s
->se_conns
, cn_persession
) {
940 if (c
->cn_flags
& NFS4_CDFC4_BACK
)
947 static void nfsd4_process_cb_update(struct nfsd4_callback
*cb
)
949 struct nfs4_cb_conn conn
;
950 struct nfs4_client
*clp
= cb
->cb_clp
;
951 struct nfsd4_session
*ses
= NULL
;
952 struct nfsd4_conn
*c
;
956 * This is either an update, or the client dying; in either case,
957 * kill the old client:
959 if (clp
->cl_cb_client
) {
960 rpc_shutdown_client(clp
->cl_cb_client
);
961 clp
->cl_cb_client
= NULL
;
962 put_rpccred(clp
->cl_cb_cred
);
963 clp
->cl_cb_cred
= NULL
;
965 if (clp
->cl_cb_conn
.cb_xprt
) {
966 svc_xprt_put(clp
->cl_cb_conn
.cb_xprt
);
967 clp
->cl_cb_conn
.cb_xprt
= NULL
;
969 if (test_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
))
971 spin_lock(&clp
->cl_lock
);
973 * Only serialized callback code is allowed to clear these
974 * flags; main nfsd code can only set them:
976 BUG_ON(!(clp
->cl_flags
& NFSD4_CLIENT_CB_FLAG_MASK
));
977 clear_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
);
978 memcpy(&conn
, &cb
->cb_clp
->cl_cb_conn
, sizeof(struct nfs4_cb_conn
));
979 c
= __nfsd4_find_backchannel(clp
);
981 svc_xprt_get(c
->cn_xprt
);
982 conn
.cb_xprt
= c
->cn_xprt
;
985 spin_unlock(&clp
->cl_lock
);
987 err
= setup_callback_client(clp
, &conn
, ses
);
989 nfsd4_mark_cb_down(clp
, err
);
992 /* Yay, the callback channel's back! Restart any callbacks: */
993 list_for_each_entry(cb
, &clp
->cl_callbacks
, cb_per_client
)
997 static void nfsd4_do_callback_rpc(struct work_struct
*w
)
999 struct nfsd4_callback
*cb
= container_of(w
, struct nfsd4_callback
, cb_work
);
1000 struct nfs4_client
*clp
= cb
->cb_clp
;
1001 struct rpc_clnt
*clnt
;
1003 if (clp
->cl_flags
& NFSD4_CLIENT_CB_FLAG_MASK
)
1004 nfsd4_process_cb_update(cb
);
1006 clnt
= clp
->cl_cb_client
;
1008 /* Callback channel broken, or client killed; give up: */
1009 nfsd4_release_cb(cb
);
1012 cb
->cb_msg
.rpc_cred
= clp
->cl_cb_cred
;
1013 rpc_call_async(clnt
, &cb
->cb_msg
, RPC_TASK_SOFT
| RPC_TASK_SOFTCONN
,
1017 void nfsd4_init_callback(struct nfsd4_callback
*cb
)
1019 INIT_WORK(&cb
->cb_work
, nfsd4_do_callback_rpc
);
1022 void nfsd4_cb_recall(struct nfs4_delegation
*dp
)
1024 struct nfsd4_callback
*cb
= &dp
->dl_recall
;
1025 struct nfs4_client
*clp
= dp
->dl_stid
.sc_client
;
1030 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_RECALL
];
1031 cb
->cb_msg
.rpc_argp
= cb
;
1032 cb
->cb_msg
.rpc_resp
= cb
;
1034 cb
->cb_ops
= &nfsd4_cb_recall_ops
;
1036 INIT_LIST_HEAD(&cb
->cb_per_client
);
1039 run_nfsd4_cb(&dp
->dl_recall
);