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>
43 #define NFSDDBG_FACILITY NFSDDBG_PROC
45 static void nfsd4_mark_cb_fault(struct nfs4_client
*, int reason
);
47 #define NFSPROC4_CB_NULL 0
48 #define NFSPROC4_CB_COMPOUND 1
50 /* Index of predefined Linux callback client operations */
53 NFSPROC4_CLNT_CB_NULL
= 0,
54 NFSPROC4_CLNT_CB_RECALL
,
55 NFSPROC4_CLNT_CB_SEQUENCE
,
58 struct nfs4_cb_compound_hdr
{
60 u32 ident
; /* minorversion 0 only */
69 * Handle decode buffer overflows out-of-line.
71 static void print_overflow_msg(const char *func
, const struct xdr_stream
*xdr
)
73 dprintk("NFS: %s prematurely hit the end of our receive buffer. "
74 "Remaining buffer length is %tu words.\n",
75 func
, xdr
->end
- xdr
->p
);
78 static __be32
*xdr_encode_empty_array(__be32
*p
)
85 * Encode/decode NFSv4 CB basic data types
87 * Basic NFSv4 callback data types are defined in section 15 of RFC
88 * 3530: "Network File System (NFS) version 4 Protocol" and section
89 * 20 of RFC 5661: "Network File System (NFS) Version 4 Minor Version
96 * enum nfs_cb_opnum4 {
104 OP_CB_LAYOUTRECALL
= 5,
106 OP_CB_PUSH_DELEG
= 7,
107 OP_CB_RECALL_ANY
= 8,
108 OP_CB_RECALLABLE_OBJ_AVAIL
= 9,
109 OP_CB_RECALL_SLOT
= 10,
111 OP_CB_WANTS_CANCELLED
= 12,
112 OP_CB_NOTIFY_LOCK
= 13,
113 OP_CB_NOTIFY_DEVICEID
= 14,
114 OP_CB_ILLEGAL
= 10044
117 static void encode_nfs_cb_opnum4(struct xdr_stream
*xdr
, enum nfs_cb_opnum4 op
)
121 p
= xdr_reserve_space(xdr
, 4);
122 *p
= cpu_to_be32(op
);
128 * typedef opaque nfs_fh4<NFS4_FHSIZE>;
130 static void encode_nfs_fh4(struct xdr_stream
*xdr
, const struct knfsd_fh
*fh
)
132 u32 length
= fh
->fh_size
;
135 BUG_ON(length
> NFS4_FHSIZE
);
136 p
= xdr_reserve_space(xdr
, 4 + length
);
137 xdr_encode_opaque(p
, &fh
->fh_base
, length
);
148 static void encode_stateid4(struct xdr_stream
*xdr
, const stateid_t
*sid
)
152 p
= xdr_reserve_space(xdr
, NFS4_STATEID_SIZE
);
153 *p
++ = cpu_to_be32(sid
->si_generation
);
154 xdr_encode_opaque_fixed(p
, &sid
->si_opaque
, NFS4_STATEID_OTHER_SIZE
);
160 * typedef opaque sessionid4[NFS4_SESSIONID_SIZE];
162 static void encode_sessionid4(struct xdr_stream
*xdr
,
163 const struct nfsd4_session
*session
)
167 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
);
168 xdr_encode_opaque_fixed(p
, session
->se_sessionid
.data
,
169 NFS4_MAX_SESSIONID_LEN
);
175 static const struct {
178 } nfs_cb_errtbl
[] = {
180 { NFS4ERR_PERM
, -EPERM
},
181 { NFS4ERR_NOENT
, -ENOENT
},
182 { NFS4ERR_IO
, -EIO
},
183 { NFS4ERR_NXIO
, -ENXIO
},
184 { NFS4ERR_ACCESS
, -EACCES
},
185 { NFS4ERR_EXIST
, -EEXIST
},
186 { NFS4ERR_XDEV
, -EXDEV
},
187 { NFS4ERR_NOTDIR
, -ENOTDIR
},
188 { NFS4ERR_ISDIR
, -EISDIR
},
189 { NFS4ERR_INVAL
, -EINVAL
},
190 { NFS4ERR_FBIG
, -EFBIG
},
191 { NFS4ERR_NOSPC
, -ENOSPC
},
192 { NFS4ERR_ROFS
, -EROFS
},
193 { NFS4ERR_MLINK
, -EMLINK
},
194 { NFS4ERR_NAMETOOLONG
, -ENAMETOOLONG
},
195 { NFS4ERR_NOTEMPTY
, -ENOTEMPTY
},
196 { NFS4ERR_DQUOT
, -EDQUOT
},
197 { NFS4ERR_STALE
, -ESTALE
},
198 { NFS4ERR_BADHANDLE
, -EBADHANDLE
},
199 { NFS4ERR_BAD_COOKIE
, -EBADCOOKIE
},
200 { NFS4ERR_NOTSUPP
, -ENOTSUPP
},
201 { NFS4ERR_TOOSMALL
, -ETOOSMALL
},
202 { NFS4ERR_SERVERFAULT
, -ESERVERFAULT
},
203 { NFS4ERR_BADTYPE
, -EBADTYPE
},
204 { NFS4ERR_LOCKED
, -EAGAIN
},
205 { NFS4ERR_RESOURCE
, -EREMOTEIO
},
206 { NFS4ERR_SYMLINK
, -ELOOP
},
207 { NFS4ERR_OP_ILLEGAL
, -EOPNOTSUPP
},
208 { NFS4ERR_DEADLOCK
, -EDEADLK
},
213 * If we cannot translate the error, the recovery routines should
216 * Note: remaining NFSv4 error codes have values > 10000, so should
217 * not conflict with native Linux error codes.
219 static int nfs_cb_stat_to_errno(int status
)
223 for (i
= 0; nfs_cb_errtbl
[i
].stat
!= -1; i
++) {
224 if (nfs_cb_errtbl
[i
].stat
== status
)
225 return nfs_cb_errtbl
[i
].errno
;
228 dprintk("NFSD: Unrecognized NFS CB status value: %u\n", status
);
232 static int decode_cb_op_status(struct xdr_stream
*xdr
, enum nfs_opnum4 expected
,
233 enum nfsstat4
*status
)
238 p
= xdr_inline_decode(xdr
, 4 + 4);
239 if (unlikely(p
== NULL
))
241 op
= be32_to_cpup(p
++);
242 if (unlikely(op
!= expected
))
244 *status
= be32_to_cpup(p
);
247 print_overflow_msg(__func__
, xdr
);
250 dprintk("NFSD: Callback server returned operation %d but "
251 "we issued a request for %d\n", op
, expected
);
258 * struct CB_COMPOUND4args {
260 * uint32_t minorversion;
261 * uint32_t callback_ident;
262 * nfs_cb_argop4 argarray<>;
265 static void encode_cb_compound4args(struct xdr_stream
*xdr
,
266 struct nfs4_cb_compound_hdr
*hdr
)
270 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4);
271 p
= xdr_encode_empty_array(p
); /* empty tag */
272 *p
++ = cpu_to_be32(hdr
->minorversion
);
273 *p
++ = cpu_to_be32(hdr
->ident
);
276 *p
= cpu_to_be32(hdr
->nops
); /* argarray element count */
280 * Update argarray element count
282 static void encode_cb_nops(struct nfs4_cb_compound_hdr
*hdr
)
284 BUG_ON(hdr
->nops
> NFS4_MAX_BACK_CHANNEL_OPS
);
285 *hdr
->nops_p
= cpu_to_be32(hdr
->nops
);
291 * struct CB_COMPOUND4res {
294 * nfs_cb_resop4 resarray<>;
297 static int decode_cb_compound4res(struct xdr_stream
*xdr
,
298 struct nfs4_cb_compound_hdr
*hdr
)
303 p
= xdr_inline_decode(xdr
, 4 + 4);
304 if (unlikely(p
== NULL
))
306 hdr
->status
= be32_to_cpup(p
++);
308 length
= be32_to_cpup(p
++);
309 p
= xdr_inline_decode(xdr
, length
+ 4);
310 if (unlikely(p
== NULL
))
312 hdr
->nops
= be32_to_cpup(p
);
315 print_overflow_msg(__func__
, xdr
);
322 * struct CB_RECALL4args {
328 static void encode_cb_recall4args(struct xdr_stream
*xdr
,
329 const struct nfs4_delegation
*dp
,
330 struct nfs4_cb_compound_hdr
*hdr
)
334 encode_nfs_cb_opnum4(xdr
, OP_CB_RECALL
);
335 encode_stateid4(xdr
, &dp
->dl_stid
.sc_stateid
);
337 p
= xdr_reserve_space(xdr
, 4);
338 *p
++ = xdr_zero
; /* truncate */
340 encode_nfs_fh4(xdr
, &dp
->dl_fh
);
348 * struct CB_SEQUENCE4args {
349 * sessionid4 csa_sessionid;
350 * sequenceid4 csa_sequenceid;
351 * slotid4 csa_slotid;
352 * slotid4 csa_highest_slotid;
353 * bool csa_cachethis;
354 * referring_call_list4 csa_referring_call_lists<>;
357 static void encode_cb_sequence4args(struct xdr_stream
*xdr
,
358 const struct nfsd4_callback
*cb
,
359 struct nfs4_cb_compound_hdr
*hdr
)
361 struct nfsd4_session
*session
= cb
->cb_clp
->cl_cb_session
;
364 if (hdr
->minorversion
== 0)
367 encode_nfs_cb_opnum4(xdr
, OP_CB_SEQUENCE
);
368 encode_sessionid4(xdr
, session
);
370 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4 + 4);
371 *p
++ = cpu_to_be32(session
->se_cb_seq_nr
); /* csa_sequenceid */
372 *p
++ = xdr_zero
; /* csa_slotid */
373 *p
++ = xdr_zero
; /* csa_highest_slotid */
374 *p
++ = xdr_zero
; /* csa_cachethis */
375 xdr_encode_empty_array(p
); /* csa_referring_call_lists */
383 * struct CB_SEQUENCE4resok {
384 * sessionid4 csr_sessionid;
385 * sequenceid4 csr_sequenceid;
386 * slotid4 csr_slotid;
387 * slotid4 csr_highest_slotid;
388 * slotid4 csr_target_highest_slotid;
391 * union CB_SEQUENCE4res switch (nfsstat4 csr_status) {
393 * CB_SEQUENCE4resok csr_resok4;
398 * Our current back channel implmentation supports a single backchannel
399 * with a single slot.
401 static int decode_cb_sequence4resok(struct xdr_stream
*xdr
,
402 struct nfsd4_callback
*cb
)
404 struct nfsd4_session
*session
= cb
->cb_clp
->cl_cb_session
;
405 struct nfs4_sessionid id
;
410 status
= -ESERVERFAULT
;
413 * If the server returns different values for sessionID, slotID or
414 * sequence number, the server is looney tunes.
416 p
= xdr_inline_decode(xdr
, NFS4_MAX_SESSIONID_LEN
+ 4 + 4 + 4 + 4);
417 if (unlikely(p
== NULL
))
419 memcpy(id
.data
, p
, NFS4_MAX_SESSIONID_LEN
);
420 if (memcmp(id
.data
, session
->se_sessionid
.data
,
421 NFS4_MAX_SESSIONID_LEN
) != 0) {
422 dprintk("NFS: %s Invalid session id\n", __func__
);
425 p
+= XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN
);
427 dummy
= be32_to_cpup(p
++);
428 if (dummy
!= session
->se_cb_seq_nr
) {
429 dprintk("NFS: %s Invalid sequence number\n", __func__
);
433 dummy
= be32_to_cpup(p
++);
435 dprintk("NFS: %s Invalid slotid\n", __func__
);
440 * FIXME: process highest slotid and target highest slotid
445 nfsd4_mark_cb_fault(cb
->cb_clp
, status
);
448 print_overflow_msg(__func__
, xdr
);
452 static int decode_cb_sequence4res(struct xdr_stream
*xdr
,
453 struct nfsd4_callback
*cb
)
455 enum nfsstat4 nfserr
;
458 if (cb
->cb_minorversion
== 0)
461 status
= decode_cb_op_status(xdr
, OP_CB_SEQUENCE
, &nfserr
);
462 if (unlikely(status
))
464 if (unlikely(nfserr
!= NFS4_OK
))
466 status
= decode_cb_sequence4resok(xdr
, cb
);
470 return nfs_cb_stat_to_errno(nfserr
);
474 * NFSv4.0 and NFSv4.1 XDR encode functions
476 * NFSv4.0 callback argument types are defined in section 15 of RFC
477 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
478 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
483 * NB: Without this zero space reservation, callbacks over krb5p fail
485 static void nfs4_xdr_enc_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
488 xdr_reserve_space(xdr
, 0);
492 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
494 static void nfs4_xdr_enc_cb_recall(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
495 const struct nfsd4_callback
*cb
)
497 const struct nfs4_delegation
*args
= cb
->cb_op
;
498 struct nfs4_cb_compound_hdr hdr
= {
499 .ident
= cb
->cb_clp
->cl_cb_ident
,
500 .minorversion
= cb
->cb_minorversion
,
503 encode_cb_compound4args(xdr
, &hdr
);
504 encode_cb_sequence4args(xdr
, cb
, &hdr
);
505 encode_cb_recall4args(xdr
, args
, &hdr
);
506 encode_cb_nops(&hdr
);
511 * NFSv4.0 and NFSv4.1 XDR decode functions
513 * NFSv4.0 callback result types are defined in section 15 of RFC
514 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
515 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
519 static int nfs4_xdr_dec_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
526 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
528 static int nfs4_xdr_dec_cb_recall(struct rpc_rqst
*rqstp
,
529 struct xdr_stream
*xdr
,
530 struct nfsd4_callback
*cb
)
532 struct nfs4_cb_compound_hdr hdr
;
533 enum nfsstat4 nfserr
;
536 status
= decode_cb_compound4res(xdr
, &hdr
);
537 if (unlikely(status
))
541 status
= decode_cb_sequence4res(xdr
, cb
);
542 if (unlikely(status
))
546 status
= decode_cb_op_status(xdr
, OP_CB_RECALL
, &nfserr
);
547 if (unlikely(status
))
549 if (unlikely(nfserr
!= NFS4_OK
))
550 status
= nfs_cb_stat_to_errno(nfserr
);
556 * RPC procedure tables
558 #define PROC(proc, call, argtype, restype) \
559 [NFSPROC4_CLNT_##proc] = { \
560 .p_proc = NFSPROC4_CB_##call, \
561 .p_encode = (kxdreproc_t)nfs4_xdr_enc_##argtype, \
562 .p_decode = (kxdrdproc_t)nfs4_xdr_dec_##restype, \
563 .p_arglen = NFS4_enc_##argtype##_sz, \
564 .p_replen = NFS4_dec_##restype##_sz, \
565 .p_statidx = NFSPROC4_CB_##call, \
569 static struct rpc_procinfo nfs4_cb_procedures
[] = {
570 PROC(CB_NULL
, NULL
, cb_null
, cb_null
),
571 PROC(CB_RECALL
, COMPOUND
, cb_recall
, cb_recall
),
574 static struct rpc_version nfs_cb_version4
= {
576 * Note on the callback rpc program version number: despite language in rfc
577 * 5661 section 18.36.3 requiring servers to use 4 in this field, the
578 * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
579 * in practice that appears to be what implementations use. The section
580 * 18.36.3 language is expected to be fixed in an erratum.
583 .nrprocs
= ARRAY_SIZE(nfs4_cb_procedures
),
584 .procs
= nfs4_cb_procedures
587 static const struct rpc_version
*nfs_cb_version
[] = {
591 static const struct rpc_program cb_program
;
593 static struct rpc_stat cb_stats
= {
594 .program
= &cb_program
597 #define NFS4_CALLBACK 0x40000000
598 static const struct rpc_program cb_program
= {
600 .number
= NFS4_CALLBACK
,
601 .nrvers
= ARRAY_SIZE(nfs_cb_version
),
602 .version
= nfs_cb_version
,
604 .pipe_dir_name
= "nfsd4_cb",
607 static int max_cb_time(struct net
*net
)
609 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
610 return max(nn
->nfsd4_lease
/10, (time_t)1) * HZ
;
613 static struct rpc_cred
*callback_cred
;
615 int set_callback_cred(void)
619 callback_cred
= rpc_lookup_machine_cred("nfs");
625 static struct rpc_cred
*get_backchannel_cred(struct nfs4_client
*clp
, struct rpc_clnt
*client
, struct nfsd4_session
*ses
)
627 if (clp
->cl_minorversion
== 0) {
628 return get_rpccred(callback_cred
);
630 struct rpc_auth
*auth
= client
->cl_auth
;
631 struct auth_cred acred
= {};
633 acred
.uid
= ses
->se_cb_sec
.uid
;
634 acred
.gid
= ses
->se_cb_sec
.gid
;
635 return auth
->au_ops
->lookup_cred(client
->cl_auth
, &acred
, 0);
639 static struct rpc_clnt
*create_backchannel_client(struct rpc_create_args
*args
)
641 struct rpc_xprt
*xprt
;
643 if (args
->protocol
!= XPRT_TRANSPORT_BC_TCP
)
644 return rpc_create(args
);
646 xprt
= args
->bc_xprt
->xpt_bc_xprt
;
649 return rpc_create_xprt(args
, xprt
);
652 return rpc_create(args
);
655 static int setup_callback_client(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
, struct nfsd4_session
*ses
)
657 struct rpc_timeout timeparms
= {
658 .to_initval
= max_cb_time(clp
->net
),
661 struct rpc_create_args args
= {
663 .address
= (struct sockaddr
*) &conn
->cb_addr
,
664 .addrsize
= conn
->cb_addrlen
,
665 .saddress
= (struct sockaddr
*) &conn
->cb_saddr
,
666 .timeout
= &timeparms
,
667 .program
= &cb_program
,
669 .flags
= (RPC_CLNT_CREATE_NOPING
| RPC_CLNT_CREATE_QUIET
),
671 struct rpc_clnt
*client
;
672 struct rpc_cred
*cred
;
674 if (clp
->cl_minorversion
== 0) {
675 if (!clp
->cl_cred
.cr_principal
&&
676 (clp
->cl_cred
.cr_flavor
>= RPC_AUTH_GSS_KRB5
))
678 args
.client_name
= clp
->cl_cred
.cr_principal
;
679 args
.prognumber
= conn
->cb_prog
,
680 args
.protocol
= XPRT_TRANSPORT_TCP
;
681 args
.authflavor
= clp
->cl_cred
.cr_flavor
;
682 clp
->cl_cb_ident
= conn
->cb_ident
;
686 clp
->cl_cb_conn
.cb_xprt
= conn
->cb_xprt
;
687 clp
->cl_cb_session
= ses
;
688 args
.bc_xprt
= conn
->cb_xprt
;
689 args
.prognumber
= clp
->cl_cb_session
->se_cb_prog
;
690 args
.protocol
= XPRT_TRANSPORT_BC_TCP
;
691 args
.authflavor
= ses
->se_cb_sec
.flavor
;
693 /* Create RPC client */
694 client
= create_backchannel_client(&args
);
695 if (IS_ERR(client
)) {
696 dprintk("NFSD: couldn't create callback client: %ld\n",
698 return PTR_ERR(client
);
700 cred
= get_backchannel_cred(clp
, client
, ses
);
702 rpc_shutdown_client(client
);
703 return PTR_ERR(cred
);
705 clp
->cl_cb_client
= client
;
706 clp
->cl_cb_cred
= cred
;
710 static void warn_no_callback_path(struct nfs4_client
*clp
, int reason
)
712 dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
713 (int)clp
->cl_name
.len
, clp
->cl_name
.data
, reason
);
716 static void nfsd4_mark_cb_down(struct nfs4_client
*clp
, int reason
)
718 clp
->cl_cb_state
= NFSD4_CB_DOWN
;
719 warn_no_callback_path(clp
, reason
);
722 static void nfsd4_mark_cb_fault(struct nfs4_client
*clp
, int reason
)
724 clp
->cl_cb_state
= NFSD4_CB_FAULT
;
725 warn_no_callback_path(clp
, reason
);
728 static void nfsd4_cb_probe_done(struct rpc_task
*task
, void *calldata
)
730 struct nfs4_client
*clp
= container_of(calldata
, struct nfs4_client
, cl_cb_null
);
733 nfsd4_mark_cb_down(clp
, task
->tk_status
);
735 clp
->cl_cb_state
= NFSD4_CB_UP
;
738 static const struct rpc_call_ops nfsd4_cb_probe_ops
= {
739 /* XXX: release method to ensure we set the cb channel down if
740 * necessary on early failure? */
741 .rpc_call_done
= nfsd4_cb_probe_done
,
744 static struct workqueue_struct
*callback_wq
;
746 static void run_nfsd4_cb(struct nfsd4_callback
*cb
)
748 queue_work(callback_wq
, &cb
->cb_work
);
751 static void do_probe_callback(struct nfs4_client
*clp
)
753 struct nfsd4_callback
*cb
= &clp
->cl_cb_null
;
758 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_NULL
];
759 cb
->cb_msg
.rpc_argp
= NULL
;
760 cb
->cb_msg
.rpc_resp
= NULL
;
762 cb
->cb_ops
= &nfsd4_cb_probe_ops
;
768 * Poke the callback thread to process any updates to the callback
769 * parameters, and send a null probe.
771 void nfsd4_probe_callback(struct nfs4_client
*clp
)
773 clp
->cl_cb_state
= NFSD4_CB_UNKNOWN
;
774 set_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
);
775 do_probe_callback(clp
);
778 void nfsd4_probe_callback_sync(struct nfs4_client
*clp
)
780 nfsd4_probe_callback(clp
);
781 flush_workqueue(callback_wq
);
784 void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
786 clp
->cl_cb_state
= NFSD4_CB_UNKNOWN
;
787 spin_lock(&clp
->cl_lock
);
788 memcpy(&clp
->cl_cb_conn
, conn
, sizeof(struct nfs4_cb_conn
));
789 spin_unlock(&clp
->cl_lock
);
793 * There's currently a single callback channel slot.
794 * If the slot is available, then mark it busy. Otherwise, set the
795 * thread for sleeping on the callback RPC wait queue.
797 static bool nfsd41_cb_get_slot(struct nfs4_client
*clp
, struct rpc_task
*task
)
799 if (test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
800 rpc_sleep_on(&clp
->cl_cb_waitq
, task
, NULL
);
801 dprintk("%s slot is busy\n", __func__
);
808 * TODO: cb_sequence should support referring call lists, cachethis, multiple
809 * slots, and mark callback channel down on communication errors.
811 static void nfsd4_cb_prepare(struct rpc_task
*task
, void *calldata
)
813 struct nfsd4_callback
*cb
= calldata
;
814 struct nfs4_client
*clp
= cb
->cb_clp
;
815 u32 minorversion
= clp
->cl_minorversion
;
817 cb
->cb_minorversion
= minorversion
;
819 if (!nfsd41_cb_get_slot(clp
, task
))
822 spin_lock(&clp
->cl_lock
);
823 if (list_empty(&cb
->cb_per_client
)) {
824 /* This is the first call, not a restart */
826 list_add(&cb
->cb_per_client
, &clp
->cl_callbacks
);
828 spin_unlock(&clp
->cl_lock
);
829 rpc_call_start(task
);
832 static void nfsd4_cb_done(struct rpc_task
*task
, void *calldata
)
834 struct nfsd4_callback
*cb
= calldata
;
835 struct nfs4_client
*clp
= cb
->cb_clp
;
837 dprintk("%s: minorversion=%d\n", __func__
,
838 clp
->cl_minorversion
);
840 if (clp
->cl_minorversion
) {
841 /* No need for lock, access serialized in nfsd4_cb_prepare */
842 ++clp
->cl_cb_session
->se_cb_seq_nr
;
843 clear_bit(0, &clp
->cl_cb_slot_busy
);
844 rpc_wake_up_next(&clp
->cl_cb_waitq
);
845 dprintk("%s: freed slot, new seqid=%d\n", __func__
,
846 clp
->cl_cb_session
->se_cb_seq_nr
);
848 /* We're done looking into the sequence information */
849 task
->tk_msg
.rpc_resp
= NULL
;
854 static void nfsd4_cb_recall_done(struct rpc_task
*task
, void *calldata
)
856 struct nfsd4_callback
*cb
= calldata
;
857 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
858 struct nfs4_client
*clp
= cb
->cb_clp
;
859 struct rpc_clnt
*current_rpc_client
= clp
->cl_cb_client
;
861 nfsd4_cb_done(task
, calldata
);
863 if (current_rpc_client
!= task
->tk_client
) {
864 /* We're shutting down or changing cl_cb_client; leave
865 * it to nfsd4_process_cb_update to restart the call if
872 switch (task
->tk_status
) {
877 case -NFS4ERR_BAD_STATEID
:
878 /* Race: client probably got cb_recall
879 * before open reply granting delegation */
882 /* Network partition? */
883 nfsd4_mark_cb_down(clp
, task
->tk_status
);
885 if (dp
->dl_retries
--) {
886 rpc_delay(task
, 2*HZ
);
888 rpc_restart_call_prepare(task
);
891 nfsd4_mark_cb_down(clp
, task
->tk_status
);
895 static void nfsd4_cb_recall_release(void *calldata
)
897 struct nfsd4_callback
*cb
= calldata
;
898 struct nfs4_client
*clp
= cb
->cb_clp
;
899 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
902 spin_lock(&clp
->cl_lock
);
903 list_del(&cb
->cb_per_client
);
904 spin_unlock(&clp
->cl_lock
);
905 nfs4_put_delegation(dp
);
909 static const struct rpc_call_ops nfsd4_cb_recall_ops
= {
910 .rpc_call_prepare
= nfsd4_cb_prepare
,
911 .rpc_call_done
= nfsd4_cb_recall_done
,
912 .rpc_release
= nfsd4_cb_recall_release
,
915 int nfsd4_create_callback_queue(void)
917 callback_wq
= create_singlethread_workqueue("nfsd4_callbacks");
923 void nfsd4_destroy_callback_queue(void)
925 destroy_workqueue(callback_wq
);
928 /* must be called under the state lock */
929 void nfsd4_shutdown_callback(struct nfs4_client
*clp
)
931 set_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
);
933 * Note this won't actually result in a null callback;
934 * instead, nfsd4_do_callback_rpc() will detect the killed
935 * client, destroy the rpc client, and stop:
937 do_probe_callback(clp
);
938 flush_workqueue(callback_wq
);
941 static void nfsd4_release_cb(struct nfsd4_callback
*cb
)
943 if (cb
->cb_ops
->rpc_release
)
944 cb
->cb_ops
->rpc_release(cb
);
947 /* requires cl_lock: */
948 static struct nfsd4_conn
* __nfsd4_find_backchannel(struct nfs4_client
*clp
)
950 struct nfsd4_session
*s
;
951 struct nfsd4_conn
*c
;
953 list_for_each_entry(s
, &clp
->cl_sessions
, se_perclnt
) {
954 list_for_each_entry(c
, &s
->se_conns
, cn_persession
) {
955 if (c
->cn_flags
& NFS4_CDFC4_BACK
)
962 static void nfsd4_process_cb_update(struct nfsd4_callback
*cb
)
964 struct nfs4_cb_conn conn
;
965 struct nfs4_client
*clp
= cb
->cb_clp
;
966 struct nfsd4_session
*ses
= NULL
;
967 struct nfsd4_conn
*c
;
971 * This is either an update, or the client dying; in either case,
972 * kill the old client:
974 if (clp
->cl_cb_client
) {
975 rpc_shutdown_client(clp
->cl_cb_client
);
976 clp
->cl_cb_client
= NULL
;
977 put_rpccred(clp
->cl_cb_cred
);
978 clp
->cl_cb_cred
= NULL
;
980 if (clp
->cl_cb_conn
.cb_xprt
) {
981 svc_xprt_put(clp
->cl_cb_conn
.cb_xprt
);
982 clp
->cl_cb_conn
.cb_xprt
= NULL
;
984 if (test_bit(NFSD4_CLIENT_CB_KILL
, &clp
->cl_flags
))
986 spin_lock(&clp
->cl_lock
);
988 * Only serialized callback code is allowed to clear these
989 * flags; main nfsd code can only set them:
991 BUG_ON(!(clp
->cl_flags
& NFSD4_CLIENT_CB_FLAG_MASK
));
992 clear_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_flags
);
993 memcpy(&conn
, &cb
->cb_clp
->cl_cb_conn
, sizeof(struct nfs4_cb_conn
));
994 c
= __nfsd4_find_backchannel(clp
);
996 svc_xprt_get(c
->cn_xprt
);
997 conn
.cb_xprt
= c
->cn_xprt
;
1000 spin_unlock(&clp
->cl_lock
);
1002 err
= setup_callback_client(clp
, &conn
, ses
);
1004 nfsd4_mark_cb_down(clp
, err
);
1007 /* Yay, the callback channel's back! Restart any callbacks: */
1008 list_for_each_entry(cb
, &clp
->cl_callbacks
, cb_per_client
)
1012 static void nfsd4_do_callback_rpc(struct work_struct
*w
)
1014 struct nfsd4_callback
*cb
= container_of(w
, struct nfsd4_callback
, cb_work
);
1015 struct nfs4_client
*clp
= cb
->cb_clp
;
1016 struct rpc_clnt
*clnt
;
1018 if (clp
->cl_flags
& NFSD4_CLIENT_CB_FLAG_MASK
)
1019 nfsd4_process_cb_update(cb
);
1021 clnt
= clp
->cl_cb_client
;
1023 /* Callback channel broken, or client killed; give up: */
1024 nfsd4_release_cb(cb
);
1027 cb
->cb_msg
.rpc_cred
= clp
->cl_cb_cred
;
1028 rpc_call_async(clnt
, &cb
->cb_msg
, RPC_TASK_SOFT
| RPC_TASK_SOFTCONN
,
1032 void nfsd4_init_callback(struct nfsd4_callback
*cb
)
1034 INIT_WORK(&cb
->cb_work
, nfsd4_do_callback_rpc
);
1037 void nfsd4_cb_recall(struct nfs4_delegation
*dp
)
1039 struct nfsd4_callback
*cb
= &dp
->dl_recall
;
1040 struct nfs4_client
*clp
= dp
->dl_stid
.sc_client
;
1045 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_RECALL
];
1046 cb
->cb_msg
.rpc_argp
= cb
;
1047 cb
->cb_msg
.rpc_resp
= cb
;
1049 cb
->cb_ops
= &nfsd4_cb_recall_ops
;
1051 INIT_LIST_HEAD(&cb
->cb_per_client
);
1054 run_nfsd4_cb(&dp
->dl_recall
);