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>
40 #define NFSDDBG_FACILITY NFSDDBG_PROC
42 #define NFSPROC4_CB_NULL 0
43 #define NFSPROC4_CB_COMPOUND 1
45 /* Index of predefined Linux callback client operations */
48 NFSPROC4_CLNT_CB_NULL = 0,
49 NFSPROC4_CLNT_CB_RECALL,
50 NFSPROC4_CLNT_CB_SEQUENCE,
53 #define NFS4_MAXTAGLEN 20
55 #define NFS4_enc_cb_null_sz 0
56 #define NFS4_dec_cb_null_sz 0
57 #define cb_compound_enc_hdr_sz 4
58 #define cb_compound_dec_hdr_sz (3 + (NFS4_MAXTAGLEN >> 2))
59 #define sessionid_sz (NFS4_MAX_SESSIONID_LEN >> 2)
60 #define cb_sequence_enc_sz (sessionid_sz + 4 + \
61 1 /* no referring calls list yet */)
62 #define cb_sequence_dec_sz (op_dec_sz + sessionid_sz + 4)
66 #define enc_nfs4_fh_sz (1 + (NFS4_FHSIZE >> 2))
67 #define enc_stateid_sz (NFS4_STATEID_SIZE >> 2)
68 #define NFS4_enc_cb_recall_sz (cb_compound_enc_hdr_sz + \
69 cb_sequence_enc_sz + \
70 1 + enc_stateid_sz + \
73 #define NFS4_dec_cb_recall_sz (cb_compound_dec_hdr_sz + \
74 cb_sequence_dec_sz + \
77 struct nfs4_cb_compound_hdr {
79 u32 ident; /* minorversion 0 only */
88 * Handle decode buffer overflows out-of-line.
90 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
92 dprintk("NFS: %s prematurely hit the end of our receive buffer. "
93 "Remaining buffer length is %tu words.\n",
94 func, xdr->end - xdr->p);
97 static __be32 *xdr_encode_empty_array(__be32 *p)
104 * Encode/decode NFSv4 CB basic data types
106 * Basic NFSv4 callback data types are defined in section 15 of RFC
107 * 3530: "Network File System (NFS) version 4 Protocol" and section
108 * 20 of RFC 5661: "Network File System (NFS) Version 4 Minor Version
115 * enum nfs_cb_opnum4 {
123 OP_CB_LAYOUTRECALL = 5,
125 OP_CB_PUSH_DELEG = 7,
126 OP_CB_RECALL_ANY = 8,
127 OP_CB_RECALLABLE_OBJ_AVAIL = 9,
128 OP_CB_RECALL_SLOT = 10,
130 OP_CB_WANTS_CANCELLED = 12,
131 OP_CB_NOTIFY_LOCK = 13,
132 OP_CB_NOTIFY_DEVICEID = 14,
133 OP_CB_ILLEGAL = 10044
136 static void encode_nfs_cb_opnum4(struct xdr_stream *xdr, enum nfs_cb_opnum4 op)
140 p = xdr_reserve_space(xdr, 4);
141 *p = cpu_to_be32(op);
147 * typedef opaque nfs_fh4<NFS4_FHSIZE>;
149 static void encode_nfs_fh4(struct xdr_stream *xdr, const struct knfsd_fh *fh)
151 u32 length = fh->fh_size;
154 BUG_ON(length > NFS4_FHSIZE);
155 p = xdr_reserve_space(xdr, 4 + length);
156 xdr_encode_opaque(p, &fh->fh_base, length);
167 static void encode_stateid4(struct xdr_stream *xdr, const stateid_t *sid)
171 p = xdr_reserve_space(xdr, NFS4_STATEID_SIZE);
172 *p++ = cpu_to_be32(sid->si_generation);
173 xdr_encode_opaque_fixed(p, &sid->si_opaque, NFS4_STATEID_OTHER_SIZE);
179 * typedef opaque sessionid4[NFS4_SESSIONID_SIZE];
181 static void encode_sessionid4(struct xdr_stream *xdr,
182 const struct nfsd4_session *session)
186 p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN);
187 xdr_encode_opaque_fixed(p, session->se_sessionid.data,
188 NFS4_MAX_SESSIONID_LEN);
194 static const struct {
197 } nfs_cb_errtbl[] = {
199 { NFS4ERR_PERM, -EPERM },
200 { NFS4ERR_NOENT, -ENOENT },
201 { NFS4ERR_IO, -EIO },
202 { NFS4ERR_NXIO, -ENXIO },
203 { NFS4ERR_ACCESS, -EACCES },
204 { NFS4ERR_EXIST, -EEXIST },
205 { NFS4ERR_XDEV, -EXDEV },
206 { NFS4ERR_NOTDIR, -ENOTDIR },
207 { NFS4ERR_ISDIR, -EISDIR },
208 { NFS4ERR_INVAL, -EINVAL },
209 { NFS4ERR_FBIG, -EFBIG },
210 { NFS4ERR_NOSPC, -ENOSPC },
211 { NFS4ERR_ROFS, -EROFS },
212 { NFS4ERR_MLINK, -EMLINK },
213 { NFS4ERR_NAMETOOLONG, -ENAMETOOLONG },
214 { NFS4ERR_NOTEMPTY, -ENOTEMPTY },
215 { NFS4ERR_DQUOT, -EDQUOT },
216 { NFS4ERR_STALE, -ESTALE },
217 { NFS4ERR_BADHANDLE, -EBADHANDLE },
218 { NFS4ERR_BAD_COOKIE, -EBADCOOKIE },
219 { NFS4ERR_NOTSUPP, -ENOTSUPP },
220 { NFS4ERR_TOOSMALL, -ETOOSMALL },
221 { NFS4ERR_SERVERFAULT, -ESERVERFAULT },
222 { NFS4ERR_BADTYPE, -EBADTYPE },
223 { NFS4ERR_LOCKED, -EAGAIN },
224 { NFS4ERR_RESOURCE, -EREMOTEIO },
225 { NFS4ERR_SYMLINK, -ELOOP },
226 { NFS4ERR_OP_ILLEGAL, -EOPNOTSUPP },
227 { NFS4ERR_DEADLOCK, -EDEADLK },
232 * If we cannot translate the error, the recovery routines should
235 * Note: remaining NFSv4 error codes have values > 10000, so should
236 * not conflict with native Linux error codes.
238 static int nfs_cb_stat_to_errno(int status)
242 for (i = 0; nfs_cb_errtbl[i].stat != -1; i++) {
243 if (nfs_cb_errtbl[i].stat == status)
244 return nfs_cb_errtbl[i].errno;
247 dprintk("NFSD: Unrecognized NFS CB status value: %u\n", status);
251 static int decode_cb_op_status(struct xdr_stream *xdr, enum nfs_opnum4 expected,
252 enum nfsstat4 *status)
257 p = xdr_inline_decode(xdr, 4 + 4);
258 if (unlikely(p == NULL))
260 op = be32_to_cpup(p++);
261 if (unlikely(op != expected))
263 *status = be32_to_cpup(p);
266 print_overflow_msg(__func__, xdr);
269 dprintk("NFSD: Callback server returned operation %d but "
270 "we issued a request for %d\n", op, expected);
277 * struct CB_COMPOUND4args {
279 * uint32_t minorversion;
280 * uint32_t callback_ident;
281 * nfs_cb_argop4 argarray<>;
284 static void encode_cb_compound4args(struct xdr_stream *xdr,
285 struct nfs4_cb_compound_hdr *hdr)
289 p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4);
290 p = xdr_encode_empty_array(p); /* empty tag */
291 *p++ = cpu_to_be32(hdr->minorversion);
292 *p++ = cpu_to_be32(hdr->ident);
295 *p = cpu_to_be32(hdr->nops); /* argarray element count */
299 * Update argarray element count
301 static void encode_cb_nops(struct nfs4_cb_compound_hdr *hdr)
303 BUG_ON(hdr->nops > NFS4_MAX_BACK_CHANNEL_OPS);
304 *hdr->nops_p = cpu_to_be32(hdr->nops);
310 * struct CB_COMPOUND4res {
313 * nfs_cb_resop4 resarray<>;
316 static int decode_cb_compound4res(struct xdr_stream *xdr,
317 struct nfs4_cb_compound_hdr *hdr)
322 p = xdr_inline_decode(xdr, 4 + 4);
323 if (unlikely(p == NULL))
325 hdr->status = be32_to_cpup(p++);
327 length = be32_to_cpup(p++);
328 p = xdr_inline_decode(xdr, length + 4);
329 if (unlikely(p == NULL))
331 hdr->nops = be32_to_cpup(p);
334 print_overflow_msg(__func__, xdr);
341 * struct CB_RECALL4args {
347 static void encode_cb_recall4args(struct xdr_stream *xdr,
348 const struct nfs4_delegation *dp,
349 struct nfs4_cb_compound_hdr *hdr)
353 encode_nfs_cb_opnum4(xdr, OP_CB_RECALL);
354 encode_stateid4(xdr, &dp->dl_stateid);
356 p = xdr_reserve_space(xdr, 4);
357 *p++ = xdr_zero; /* truncate */
359 encode_nfs_fh4(xdr, &dp->dl_fh);
367 * struct CB_SEQUENCE4args {
368 * sessionid4 csa_sessionid;
369 * sequenceid4 csa_sequenceid;
370 * slotid4 csa_slotid;
371 * slotid4 csa_highest_slotid;
372 * bool csa_cachethis;
373 * referring_call_list4 csa_referring_call_lists<>;
376 static void encode_cb_sequence4args(struct xdr_stream *xdr,
377 const struct nfsd4_callback *cb,
378 struct nfs4_cb_compound_hdr *hdr)
380 struct nfsd4_session *session = cb->cb_clp->cl_cb_session;
383 if (hdr->minorversion == 0)
386 encode_nfs_cb_opnum4(xdr, OP_CB_SEQUENCE);
387 encode_sessionid4(xdr, session);
389 p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4 + 4);
390 *p++ = cpu_to_be32(session->se_cb_seq_nr); /* csa_sequenceid */
391 *p++ = xdr_zero; /* csa_slotid */
392 *p++ = xdr_zero; /* csa_highest_slotid */
393 *p++ = xdr_zero; /* csa_cachethis */
394 xdr_encode_empty_array(p); /* csa_referring_call_lists */
402 * struct CB_SEQUENCE4resok {
403 * sessionid4 csr_sessionid;
404 * sequenceid4 csr_sequenceid;
405 * slotid4 csr_slotid;
406 * slotid4 csr_highest_slotid;
407 * slotid4 csr_target_highest_slotid;
410 * union CB_SEQUENCE4res switch (nfsstat4 csr_status) {
412 * CB_SEQUENCE4resok csr_resok4;
417 * Our current back channel implmentation supports a single backchannel
418 * with a single slot.
420 static int decode_cb_sequence4resok(struct xdr_stream *xdr,
421 struct nfsd4_callback *cb)
423 struct nfsd4_session *session = cb->cb_clp->cl_cb_session;
424 struct nfs4_sessionid id;
429 status = -ESERVERFAULT;
432 * If the server returns different values for sessionID, slotID or
433 * sequence number, the server is looney tunes.
435 p = xdr_inline_decode(xdr, NFS4_MAX_SESSIONID_LEN + 4 + 4);
436 if (unlikely(p == NULL))
438 memcpy(id.data, p, NFS4_MAX_SESSIONID_LEN);
439 if (memcmp(id.data, session->se_sessionid.data,
440 NFS4_MAX_SESSIONID_LEN) != 0) {
441 dprintk("NFS: %s Invalid session id\n", __func__);
444 p += XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN);
446 dummy = be32_to_cpup(p++);
447 if (dummy != session->se_cb_seq_nr) {
448 dprintk("NFS: %s Invalid sequence number\n", __func__);
452 dummy = be32_to_cpup(p++);
454 dprintk("NFS: %s Invalid slotid\n", __func__);
459 * FIXME: process highest slotid and target highest slotid
465 print_overflow_msg(__func__, xdr);
469 static int decode_cb_sequence4res(struct xdr_stream *xdr,
470 struct nfsd4_callback *cb)
472 enum nfsstat4 nfserr;
475 if (cb->cb_minorversion == 0)
478 status = decode_cb_op_status(xdr, OP_CB_SEQUENCE, &nfserr);
479 if (unlikely(status))
481 if (unlikely(nfserr != NFS4_OK))
483 status = decode_cb_sequence4resok(xdr, cb);
487 return nfs_cb_stat_to_errno(status);
491 * NFSv4.0 and NFSv4.1 XDR encode functions
493 * NFSv4.0 callback argument types are defined in section 15 of RFC
494 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
495 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
500 * NB: Without this zero space reservation, callbacks over krb5p fail
502 static int nfs4_xdr_enc_cb_null(struct rpc_rqst *req, __be32 *p, void *__unused)
504 struct xdr_stream xdrs, *xdr = &xdrs;
506 xdr_init_encode(&xdrs, &req->rq_snd_buf, p);
507 xdr_reserve_space(xdr, 0);
512 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
514 static int nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, __be32 *p,
515 const struct nfsd4_callback *cb)
517 struct xdr_stream xdr;
518 const struct nfs4_delegation *args = cb->cb_op;
519 struct nfs4_cb_compound_hdr hdr = {
520 .ident = cb->cb_clp->cl_cb_ident,
521 .minorversion = cb->cb_minorversion,
524 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
525 encode_cb_compound4args(&xdr, &hdr);
526 encode_cb_sequence4args(&xdr, cb, &hdr);
527 encode_cb_recall4args(&xdr, args, &hdr);
528 encode_cb_nops(&hdr);
534 * NFSv4.0 and NFSv4.1 XDR decode functions
536 * NFSv4.0 callback result types are defined in section 15 of RFC
537 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
538 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
542 static int nfs4_xdr_dec_cb_null(struct rpc_rqst *req, __be32 *p, void *__unused)
548 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
550 static int nfs4_xdr_dec_cb_recall(struct rpc_rqst *rqstp, __be32 *p,
551 struct nfsd4_callback *cb)
553 struct xdr_stream xdr;
554 struct nfs4_cb_compound_hdr hdr;
555 enum nfsstat4 nfserr;
558 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
559 status = decode_cb_compound4res(&xdr, &hdr);
560 if (unlikely(status))
564 status = decode_cb_sequence4res(&xdr, cb);
565 if (unlikely(status))
569 status = decode_cb_op_status(&xdr, OP_CB_RECALL, &nfserr);
570 if (unlikely(status))
572 if (unlikely(nfserr != NFS4_OK))
577 return nfs_cb_stat_to_errno(status);
581 * RPC procedure tables
583 #define PROC(proc, call, argtype, restype) \
584 [NFSPROC4_CLNT_##proc] = { \
585 .p_proc = NFSPROC4_CB_##call, \
586 .p_encode = (kxdrproc_t)nfs4_xdr_enc_##argtype, \
587 .p_decode = (kxdrproc_t)nfs4_xdr_dec_##restype, \
588 .p_arglen = NFS4_enc_##argtype##_sz, \
589 .p_replen = NFS4_dec_##restype##_sz, \
590 .p_statidx = NFSPROC4_CB_##call, \
594 static struct rpc_procinfo nfs4_cb_procedures[] = {
595 PROC(CB_NULL, NULL, cb_null, cb_null),
596 PROC(CB_RECALL, COMPOUND, cb_recall, cb_recall),
599 static struct rpc_version nfs_cb_version4 = {
601 * Note on the callback rpc program version number: despite language in rfc
602 * 5661 section 18.36.3 requiring servers to use 4 in this field, the
603 * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
604 * in practice that appears to be what implementations use. The section
605 * 18.36.3 language is expected to be fixed in an erratum.
608 .nrprocs = ARRAY_SIZE(nfs4_cb_procedures),
609 .procs = nfs4_cb_procedures
612 static struct rpc_version *nfs_cb_version[] = {
616 static struct rpc_program cb_program;
618 static struct rpc_stat cb_stats = {
619 .program = &cb_program
622 #define NFS4_CALLBACK 0x40000000
623 static struct rpc_program cb_program = {
625 .number = NFS4_CALLBACK,
626 .nrvers = ARRAY_SIZE(nfs_cb_version),
627 .version = nfs_cb_version,
629 .pipe_dir_name = "/nfsd4_cb",
632 static int max_cb_time(void)
634 return max(nfsd4_lease/10, (time_t)1) * HZ;
637 /* Reference counting, callback cleanup, etc., all look racy as heck.
638 * And why is cl_cb_set an atomic? */
640 int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *conn)
642 struct rpc_timeout timeparms = {
643 .to_initval = max_cb_time(),
646 struct rpc_create_args args = {
648 .address = (struct sockaddr *) &conn->cb_addr,
649 .addrsize = conn->cb_addrlen,
650 .timeout = &timeparms,
651 .program = &cb_program,
653 .authflavor = clp->cl_flavor,
654 .flags = (RPC_CLNT_CREATE_NOPING | RPC_CLNT_CREATE_QUIET),
656 struct rpc_clnt *client;
658 if (clp->cl_minorversion == 0) {
659 if (!clp->cl_principal && (clp->cl_flavor >= RPC_AUTH_GSS_KRB5))
661 args.client_name = clp->cl_principal;
662 args.prognumber = conn->cb_prog,
663 args.protocol = XPRT_TRANSPORT_TCP;
664 clp->cl_cb_ident = conn->cb_ident;
666 args.bc_xprt = conn->cb_xprt;
667 args.prognumber = clp->cl_cb_session->se_cb_prog;
668 args.protocol = XPRT_TRANSPORT_BC_TCP;
670 /* Create RPC client */
671 client = rpc_create(&args);
672 if (IS_ERR(client)) {
673 dprintk("NFSD: couldn't create callback client: %ld\n",
675 return PTR_ERR(client);
677 clp->cl_cb_client = client;
682 static void warn_no_callback_path(struct nfs4_client *clp, int reason)
684 dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
685 (int)clp->cl_name.len, clp->cl_name.data, reason);
688 static void nfsd4_cb_probe_done(struct rpc_task *task, void *calldata)
690 struct nfs4_client *clp = container_of(calldata, struct nfs4_client, cl_cb_null);
693 warn_no_callback_path(clp, task->tk_status);
695 atomic_set(&clp->cl_cb_set, 1);
698 static const struct rpc_call_ops nfsd4_cb_probe_ops = {
699 /* XXX: release method to ensure we set the cb channel down if
700 * necessary on early failure? */
701 .rpc_call_done = nfsd4_cb_probe_done,
704 static struct rpc_cred *callback_cred;
706 int set_callback_cred(void)
710 callback_cred = rpc_lookup_machine_cred();
716 static struct workqueue_struct *callback_wq;
718 static void do_probe_callback(struct nfs4_client *clp)
720 struct nfsd4_callback *cb = &clp->cl_cb_null;
725 cb->cb_msg.rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_NULL];
726 cb->cb_msg.rpc_argp = NULL;
727 cb->cb_msg.rpc_resp = NULL;
728 cb->cb_msg.rpc_cred = callback_cred;
730 cb->cb_ops = &nfsd4_cb_probe_ops;
732 queue_work(callback_wq, &cb->cb_work);
736 * Poke the callback thread to process any updates to the callback
737 * parameters, and send a null probe.
739 void nfsd4_probe_callback(struct nfs4_client *clp)
741 set_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_cb_flags);
742 do_probe_callback(clp);
745 void nfsd4_change_callback(struct nfs4_client *clp, struct nfs4_cb_conn *conn)
747 BUG_ON(atomic_read(&clp->cl_cb_set));
749 spin_lock(&clp->cl_lock);
750 memcpy(&clp->cl_cb_conn, conn, sizeof(struct nfs4_cb_conn));
751 spin_unlock(&clp->cl_lock);
755 * There's currently a single callback channel slot.
756 * If the slot is available, then mark it busy. Otherwise, set the
757 * thread for sleeping on the callback RPC wait queue.
759 static int nfsd41_cb_setup_sequence(struct nfs4_client *clp,
760 struct rpc_task *task)
762 u32 *ptr = (u32 *)clp->cl_cb_session->se_sessionid.data;
765 dprintk("%s: %u:%u:%u:%u\n", __func__,
766 ptr[0], ptr[1], ptr[2], ptr[3]);
768 if (test_and_set_bit(0, &clp->cl_cb_slot_busy) != 0) {
769 rpc_sleep_on(&clp->cl_cb_waitq, task, NULL);
770 dprintk("%s slot is busy\n", __func__);
775 dprintk("%s status=%d\n", __func__, status);
780 * TODO: cb_sequence should support referring call lists, cachethis, multiple
781 * slots, and mark callback channel down on communication errors.
783 static void nfsd4_cb_prepare(struct rpc_task *task, void *calldata)
785 struct nfsd4_callback *cb = calldata;
786 struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
787 struct nfs4_client *clp = dp->dl_client;
788 u32 minorversion = clp->cl_minorversion;
791 cb->cb_minorversion = minorversion;
793 status = nfsd41_cb_setup_sequence(clp, task);
795 if (status != -EAGAIN) {
796 /* terminate rpc task */
797 task->tk_status = status;
798 task->tk_action = NULL;
803 rpc_call_start(task);
806 static void nfsd4_cb_done(struct rpc_task *task, void *calldata)
808 struct nfsd4_callback *cb = calldata;
809 struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
810 struct nfs4_client *clp = dp->dl_client;
812 dprintk("%s: minorversion=%d\n", __func__,
813 clp->cl_minorversion);
815 if (clp->cl_minorversion) {
816 /* No need for lock, access serialized in nfsd4_cb_prepare */
817 ++clp->cl_cb_session->se_cb_seq_nr;
818 clear_bit(0, &clp->cl_cb_slot_busy);
819 rpc_wake_up_next(&clp->cl_cb_waitq);
820 dprintk("%s: freed slot, new seqid=%d\n", __func__,
821 clp->cl_cb_session->se_cb_seq_nr);
823 /* We're done looking into the sequence information */
824 task->tk_msg.rpc_resp = NULL;
829 static void nfsd4_cb_recall_done(struct rpc_task *task, void *calldata)
831 struct nfsd4_callback *cb = calldata;
832 struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
833 struct nfs4_client *clp = dp->dl_client;
834 struct rpc_clnt *current_rpc_client = clp->cl_cb_client;
836 nfsd4_cb_done(task, calldata);
838 if (current_rpc_client == NULL) {
839 /* We're shutting down; give up. */
840 /* XXX: err, or is it ok just to fall through
841 * and rpc_restart_call? */
845 switch (task->tk_status) {
849 case -NFS4ERR_BAD_STATEID:
850 /* Race: client probably got cb_recall
851 * before open reply granting delegation */
854 /* Network partition? */
855 atomic_set(&clp->cl_cb_set, 0);
856 warn_no_callback_path(clp, task->tk_status);
857 if (current_rpc_client != task->tk_client) {
858 /* queue a callback on the new connection: */
859 atomic_inc(&dp->dl_count);
864 if (dp->dl_retries--) {
865 rpc_delay(task, 2*HZ);
867 rpc_restart_call_prepare(task);
870 atomic_set(&clp->cl_cb_set, 0);
871 warn_no_callback_path(clp, task->tk_status);
875 static void nfsd4_cb_recall_release(void *calldata)
877 struct nfsd4_callback *cb = calldata;
878 struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
880 nfs4_put_delegation(dp);
883 static const struct rpc_call_ops nfsd4_cb_recall_ops = {
884 .rpc_call_prepare = nfsd4_cb_prepare,
885 .rpc_call_done = nfsd4_cb_recall_done,
886 .rpc_release = nfsd4_cb_recall_release,
889 int nfsd4_create_callback_queue(void)
891 callback_wq = create_singlethread_workqueue("nfsd4_callbacks");
897 void nfsd4_destroy_callback_queue(void)
899 destroy_workqueue(callback_wq);
902 /* must be called under the state lock */
903 void nfsd4_shutdown_callback(struct nfs4_client *clp)
905 set_bit(NFSD4_CLIENT_KILL, &clp->cl_cb_flags);
907 * Note this won't actually result in a null callback;
908 * instead, nfsd4_do_callback_rpc() will detect the killed
909 * client, destroy the rpc client, and stop:
911 do_probe_callback(clp);
912 flush_workqueue(callback_wq);
915 void nfsd4_release_cb(struct nfsd4_callback *cb)
917 if (cb->cb_ops->rpc_release)
918 cb->cb_ops->rpc_release(cb);
921 void nfsd4_process_cb_update(struct nfsd4_callback *cb)
923 struct nfs4_cb_conn conn;
924 struct nfs4_client *clp = cb->cb_clp;
928 * This is either an update, or the client dying; in either case,
929 * kill the old client:
931 if (clp->cl_cb_client) {
932 rpc_shutdown_client(clp->cl_cb_client);
933 clp->cl_cb_client = NULL;
935 if (test_bit(NFSD4_CLIENT_KILL, &clp->cl_cb_flags))
937 spin_lock(&clp->cl_lock);
939 * Only serialized callback code is allowed to clear these
940 * flags; main nfsd code can only set them:
942 BUG_ON(!clp->cl_cb_flags);
943 clear_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_cb_flags);
944 memcpy(&conn, &cb->cb_clp->cl_cb_conn, sizeof(struct nfs4_cb_conn));
945 spin_unlock(&clp->cl_lock);
947 err = setup_callback_client(clp, &conn);
949 warn_no_callback_path(clp, err);
952 void nfsd4_do_callback_rpc(struct work_struct *w)
954 struct nfsd4_callback *cb = container_of(w, struct nfsd4_callback, cb_work);
955 struct nfs4_client *clp = cb->cb_clp;
956 struct rpc_clnt *clnt;
958 if (clp->cl_cb_flags)
959 nfsd4_process_cb_update(cb);
961 clnt = clp->cl_cb_client;
963 /* Callback channel broken, or client killed; give up: */
964 nfsd4_release_cb(cb);
967 rpc_call_async(clnt, &cb->cb_msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN,
971 void nfsd4_cb_recall(struct nfs4_delegation *dp)
973 struct nfsd4_callback *cb = &dp->dl_recall;
977 cb->cb_clp = dp->dl_client;
978 cb->cb_msg.rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_RECALL];
979 cb->cb_msg.rpc_argp = cb;
980 cb->cb_msg.rpc_resp = cb;
981 cb->cb_msg.rpc_cred = callback_cred;
983 cb->cb_ops = &nfsd4_cb_recall_ops;
986 queue_work(callback_wq, &dp->dl_recall.cb_work);