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 void nfs4_xdr_enc_cb_null(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
505 xdr_reserve_space(xdr
, 0);
509 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
511 static void nfs4_xdr_enc_cb_recall(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
512 const struct nfsd4_callback
*cb
)
514 const struct nfs4_delegation
*args
= cb
->cb_op
;
515 struct nfs4_cb_compound_hdr hdr
= {
516 .ident
= cb
->cb_clp
->cl_cb_ident
,
517 .minorversion
= cb
->cb_minorversion
,
520 encode_cb_compound4args(xdr
, &hdr
);
521 encode_cb_sequence4args(xdr
, cb
, &hdr
);
522 encode_cb_recall4args(xdr
, args
, &hdr
);
523 encode_cb_nops(&hdr
);
528 * NFSv4.0 and NFSv4.1 XDR decode functions
530 * NFSv4.0 callback result types are defined in section 15 of RFC
531 * 3530: "Network File System (NFS) version 4 Protocol" and section 20
532 * of RFC 5661: "Network File System (NFS) Version 4 Minor Version 1
536 static int nfs4_xdr_dec_cb_null(struct rpc_rqst
*req
, __be32
*p
, void *__unused
)
542 * 20.2. Operation 4: CB_RECALL - Recall a Delegation
544 static int nfs4_xdr_dec_cb_recall(struct rpc_rqst
*rqstp
, __be32
*p
,
545 struct nfsd4_callback
*cb
)
547 struct xdr_stream xdr
;
548 struct nfs4_cb_compound_hdr hdr
;
549 enum nfsstat4 nfserr
;
552 xdr_init_decode(&xdr
, &rqstp
->rq_rcv_buf
, p
);
553 status
= decode_cb_compound4res(&xdr
, &hdr
);
554 if (unlikely(status
))
558 status
= decode_cb_sequence4res(&xdr
, cb
);
559 if (unlikely(status
))
563 status
= decode_cb_op_status(&xdr
, OP_CB_RECALL
, &nfserr
);
564 if (unlikely(status
))
566 if (unlikely(nfserr
!= NFS4_OK
))
571 return nfs_cb_stat_to_errno(status
);
575 * RPC procedure tables
577 #define PROC(proc, call, argtype, restype) \
578 [NFSPROC4_CLNT_##proc] = { \
579 .p_proc = NFSPROC4_CB_##call, \
580 .p_encode = (kxdreproc_t)nfs4_xdr_enc_##argtype, \
581 .p_decode = (kxdrproc_t)nfs4_xdr_dec_##restype, \
582 .p_arglen = NFS4_enc_##argtype##_sz, \
583 .p_replen = NFS4_dec_##restype##_sz, \
584 .p_statidx = NFSPROC4_CB_##call, \
588 static struct rpc_procinfo nfs4_cb_procedures
[] = {
589 PROC(CB_NULL
, NULL
, cb_null
, cb_null
),
590 PROC(CB_RECALL
, COMPOUND
, cb_recall
, cb_recall
),
593 static struct rpc_version nfs_cb_version4
= {
595 * Note on the callback rpc program version number: despite language in rfc
596 * 5661 section 18.36.3 requiring servers to use 4 in this field, the
597 * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
598 * in practice that appears to be what implementations use. The section
599 * 18.36.3 language is expected to be fixed in an erratum.
602 .nrprocs
= ARRAY_SIZE(nfs4_cb_procedures
),
603 .procs
= nfs4_cb_procedures
606 static struct rpc_version
*nfs_cb_version
[] = {
610 static struct rpc_program cb_program
;
612 static struct rpc_stat cb_stats
= {
613 .program
= &cb_program
616 #define NFS4_CALLBACK 0x40000000
617 static struct rpc_program cb_program
= {
619 .number
= NFS4_CALLBACK
,
620 .nrvers
= ARRAY_SIZE(nfs_cb_version
),
621 .version
= nfs_cb_version
,
623 .pipe_dir_name
= "/nfsd4_cb",
626 static int max_cb_time(void)
628 return max(nfsd4_lease
/10, (time_t)1) * HZ
;
631 /* Reference counting, callback cleanup, etc., all look racy as heck.
632 * And why is cl_cb_set an atomic? */
634 int setup_callback_client(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
636 struct rpc_timeout timeparms
= {
637 .to_initval
= max_cb_time(),
640 struct rpc_create_args args
= {
642 .address
= (struct sockaddr
*) &conn
->cb_addr
,
643 .addrsize
= conn
->cb_addrlen
,
644 .timeout
= &timeparms
,
645 .program
= &cb_program
,
647 .authflavor
= clp
->cl_flavor
,
648 .flags
= (RPC_CLNT_CREATE_NOPING
| RPC_CLNT_CREATE_QUIET
),
650 struct rpc_clnt
*client
;
652 if (clp
->cl_minorversion
== 0) {
653 if (!clp
->cl_principal
&& (clp
->cl_flavor
>= RPC_AUTH_GSS_KRB5
))
655 args
.client_name
= clp
->cl_principal
;
656 args
.prognumber
= conn
->cb_prog
,
657 args
.protocol
= XPRT_TRANSPORT_TCP
;
658 clp
->cl_cb_ident
= conn
->cb_ident
;
660 args
.bc_xprt
= conn
->cb_xprt
;
661 args
.prognumber
= clp
->cl_cb_session
->se_cb_prog
;
662 args
.protocol
= XPRT_TRANSPORT_BC_TCP
;
664 /* Create RPC client */
665 client
= rpc_create(&args
);
666 if (IS_ERR(client
)) {
667 dprintk("NFSD: couldn't create callback client: %ld\n",
669 return PTR_ERR(client
);
671 clp
->cl_cb_client
= client
;
676 static void warn_no_callback_path(struct nfs4_client
*clp
, int reason
)
678 dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
679 (int)clp
->cl_name
.len
, clp
->cl_name
.data
, reason
);
682 static void nfsd4_cb_probe_done(struct rpc_task
*task
, void *calldata
)
684 struct nfs4_client
*clp
= container_of(calldata
, struct nfs4_client
, cl_cb_null
);
687 warn_no_callback_path(clp
, task
->tk_status
);
689 atomic_set(&clp
->cl_cb_set
, 1);
692 static const struct rpc_call_ops nfsd4_cb_probe_ops
= {
693 /* XXX: release method to ensure we set the cb channel down if
694 * necessary on early failure? */
695 .rpc_call_done
= nfsd4_cb_probe_done
,
698 static struct rpc_cred
*callback_cred
;
700 int set_callback_cred(void)
704 callback_cred
= rpc_lookup_machine_cred();
710 static struct workqueue_struct
*callback_wq
;
712 static void do_probe_callback(struct nfs4_client
*clp
)
714 struct nfsd4_callback
*cb
= &clp
->cl_cb_null
;
719 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_NULL
];
720 cb
->cb_msg
.rpc_argp
= NULL
;
721 cb
->cb_msg
.rpc_resp
= NULL
;
722 cb
->cb_msg
.rpc_cred
= callback_cred
;
724 cb
->cb_ops
= &nfsd4_cb_probe_ops
;
726 queue_work(callback_wq
, &cb
->cb_work
);
730 * Poke the callback thread to process any updates to the callback
731 * parameters, and send a null probe.
733 void nfsd4_probe_callback(struct nfs4_client
*clp
)
735 set_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_cb_flags
);
736 do_probe_callback(clp
);
739 void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
741 BUG_ON(atomic_read(&clp
->cl_cb_set
));
743 spin_lock(&clp
->cl_lock
);
744 memcpy(&clp
->cl_cb_conn
, conn
, sizeof(struct nfs4_cb_conn
));
745 spin_unlock(&clp
->cl_lock
);
749 * There's currently a single callback channel slot.
750 * If the slot is available, then mark it busy. Otherwise, set the
751 * thread for sleeping on the callback RPC wait queue.
753 static int nfsd41_cb_setup_sequence(struct nfs4_client
*clp
,
754 struct rpc_task
*task
)
756 u32
*ptr
= (u32
*)clp
->cl_cb_session
->se_sessionid
.data
;
759 dprintk("%s: %u:%u:%u:%u\n", __func__
,
760 ptr
[0], ptr
[1], ptr
[2], ptr
[3]);
762 if (test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
763 rpc_sleep_on(&clp
->cl_cb_waitq
, task
, NULL
);
764 dprintk("%s slot is busy\n", __func__
);
769 dprintk("%s status=%d\n", __func__
, status
);
774 * TODO: cb_sequence should support referring call lists, cachethis, multiple
775 * slots, and mark callback channel down on communication errors.
777 static void nfsd4_cb_prepare(struct rpc_task
*task
, void *calldata
)
779 struct nfsd4_callback
*cb
= calldata
;
780 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
781 struct nfs4_client
*clp
= dp
->dl_client
;
782 u32 minorversion
= clp
->cl_minorversion
;
785 cb
->cb_minorversion
= minorversion
;
787 status
= nfsd41_cb_setup_sequence(clp
, task
);
789 if (status
!= -EAGAIN
) {
790 /* terminate rpc task */
791 task
->tk_status
= status
;
792 task
->tk_action
= NULL
;
797 rpc_call_start(task
);
800 static void nfsd4_cb_done(struct rpc_task
*task
, void *calldata
)
802 struct nfsd4_callback
*cb
= calldata
;
803 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
804 struct nfs4_client
*clp
= dp
->dl_client
;
806 dprintk("%s: minorversion=%d\n", __func__
,
807 clp
->cl_minorversion
);
809 if (clp
->cl_minorversion
) {
810 /* No need for lock, access serialized in nfsd4_cb_prepare */
811 ++clp
->cl_cb_session
->se_cb_seq_nr
;
812 clear_bit(0, &clp
->cl_cb_slot_busy
);
813 rpc_wake_up_next(&clp
->cl_cb_waitq
);
814 dprintk("%s: freed slot, new seqid=%d\n", __func__
,
815 clp
->cl_cb_session
->se_cb_seq_nr
);
817 /* We're done looking into the sequence information */
818 task
->tk_msg
.rpc_resp
= NULL
;
823 static void nfsd4_cb_recall_done(struct rpc_task
*task
, void *calldata
)
825 struct nfsd4_callback
*cb
= calldata
;
826 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
827 struct nfs4_client
*clp
= dp
->dl_client
;
828 struct rpc_clnt
*current_rpc_client
= clp
->cl_cb_client
;
830 nfsd4_cb_done(task
, calldata
);
832 if (current_rpc_client
== NULL
) {
833 /* We're shutting down; give up. */
834 /* XXX: err, or is it ok just to fall through
835 * and rpc_restart_call? */
839 switch (task
->tk_status
) {
843 case -NFS4ERR_BAD_STATEID
:
844 /* Race: client probably got cb_recall
845 * before open reply granting delegation */
848 /* Network partition? */
849 atomic_set(&clp
->cl_cb_set
, 0);
850 warn_no_callback_path(clp
, task
->tk_status
);
851 if (current_rpc_client
!= task
->tk_client
) {
852 /* queue a callback on the new connection: */
853 atomic_inc(&dp
->dl_count
);
858 if (dp
->dl_retries
--) {
859 rpc_delay(task
, 2*HZ
);
861 rpc_restart_call_prepare(task
);
864 atomic_set(&clp
->cl_cb_set
, 0);
865 warn_no_callback_path(clp
, task
->tk_status
);
869 static void nfsd4_cb_recall_release(void *calldata
)
871 struct nfsd4_callback
*cb
= calldata
;
872 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
874 nfs4_put_delegation(dp
);
877 static const struct rpc_call_ops nfsd4_cb_recall_ops
= {
878 .rpc_call_prepare
= nfsd4_cb_prepare
,
879 .rpc_call_done
= nfsd4_cb_recall_done
,
880 .rpc_release
= nfsd4_cb_recall_release
,
883 int nfsd4_create_callback_queue(void)
885 callback_wq
= create_singlethread_workqueue("nfsd4_callbacks");
891 void nfsd4_destroy_callback_queue(void)
893 destroy_workqueue(callback_wq
);
896 /* must be called under the state lock */
897 void nfsd4_shutdown_callback(struct nfs4_client
*clp
)
899 set_bit(NFSD4_CLIENT_KILL
, &clp
->cl_cb_flags
);
901 * Note this won't actually result in a null callback;
902 * instead, nfsd4_do_callback_rpc() will detect the killed
903 * client, destroy the rpc client, and stop:
905 do_probe_callback(clp
);
906 flush_workqueue(callback_wq
);
909 void nfsd4_release_cb(struct nfsd4_callback
*cb
)
911 if (cb
->cb_ops
->rpc_release
)
912 cb
->cb_ops
->rpc_release(cb
);
915 void nfsd4_process_cb_update(struct nfsd4_callback
*cb
)
917 struct nfs4_cb_conn conn
;
918 struct nfs4_client
*clp
= cb
->cb_clp
;
922 * This is either an update, or the client dying; in either case,
923 * kill the old client:
925 if (clp
->cl_cb_client
) {
926 rpc_shutdown_client(clp
->cl_cb_client
);
927 clp
->cl_cb_client
= NULL
;
929 if (test_bit(NFSD4_CLIENT_KILL
, &clp
->cl_cb_flags
))
931 spin_lock(&clp
->cl_lock
);
933 * Only serialized callback code is allowed to clear these
934 * flags; main nfsd code can only set them:
936 BUG_ON(!clp
->cl_cb_flags
);
937 clear_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_cb_flags
);
938 memcpy(&conn
, &cb
->cb_clp
->cl_cb_conn
, sizeof(struct nfs4_cb_conn
));
939 spin_unlock(&clp
->cl_lock
);
941 err
= setup_callback_client(clp
, &conn
);
943 warn_no_callback_path(clp
, err
);
946 void nfsd4_do_callback_rpc(struct work_struct
*w
)
948 struct nfsd4_callback
*cb
= container_of(w
, struct nfsd4_callback
, cb_work
);
949 struct nfs4_client
*clp
= cb
->cb_clp
;
950 struct rpc_clnt
*clnt
;
952 if (clp
->cl_cb_flags
)
953 nfsd4_process_cb_update(cb
);
955 clnt
= clp
->cl_cb_client
;
957 /* Callback channel broken, or client killed; give up: */
958 nfsd4_release_cb(cb
);
961 rpc_call_async(clnt
, &cb
->cb_msg
, RPC_TASK_SOFT
| RPC_TASK_SOFTCONN
,
965 void nfsd4_cb_recall(struct nfs4_delegation
*dp
)
967 struct nfsd4_callback
*cb
= &dp
->dl_recall
;
971 cb
->cb_clp
= dp
->dl_client
;
972 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_RECALL
];
973 cb
->cb_msg
.rpc_argp
= cb
;
974 cb
->cb_msg
.rpc_resp
= cb
;
975 cb
->cb_msg
.rpc_cred
= callback_cred
;
977 cb
->cb_ops
= &nfsd4_cb_recall_ops
;
980 queue_work(callback_wq
, &dp
->dl_recall
.cb_work
);