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
,
58 #define NFS4_MAXTAGLEN 20
60 #define NFS4_enc_cb_null_sz 0
61 #define NFS4_dec_cb_null_sz 0
62 #define cb_compound_enc_hdr_sz 4
63 #define cb_compound_dec_hdr_sz (3 + (NFS4_MAXTAGLEN >> 2))
64 #define sessionid_sz (NFS4_MAX_SESSIONID_LEN >> 2)
65 #define cb_sequence_enc_sz (sessionid_sz + 4 + \
66 1 /* no referring calls list yet */)
67 #define cb_sequence_dec_sz (op_dec_sz + sessionid_sz + 4)
71 #define enc_nfs4_fh_sz (1 + (NFS4_FHSIZE >> 2))
72 #define enc_stateid_sz (NFS4_STATEID_SIZE >> 2)
73 #define NFS4_enc_cb_recall_sz (cb_compound_enc_hdr_sz + \
74 cb_sequence_enc_sz + \
75 1 + enc_stateid_sz + \
78 #define NFS4_dec_cb_recall_sz (cb_compound_dec_hdr_sz + \
79 cb_sequence_dec_sz + \
83 * Generic encode routines from fs/nfs/nfs4xdr.c
85 static inline __be32
*
86 xdr_writemem(__be32
*p
, const void *ptr
, int nbytes
)
88 int tmp
= XDR_QUADLEN(nbytes
);
92 memcpy(p
, ptr
, nbytes
);
96 #define WRITE32(n) *p++ = htonl(n)
97 #define WRITEMEM(ptr,nbytes) do { \
98 p = xdr_writemem(p, ptr, nbytes); \
100 #define RESERVE_SPACE(nbytes) do { \
101 p = xdr_reserve_space(xdr, nbytes); \
102 if (!p) dprintk("NFSD: RESERVE_SPACE(%d) failed in function %s\n", (int) (nbytes), __func__); \
107 * Generic decode routines from fs/nfs/nfs4xdr.c
109 #define DECODE_TAIL \
114 dprintk("NFSD: xdr error! (%s:%d)\n", __FILE__, __LINE__); \
118 #define READ32(x) (x) = ntohl(*p++)
119 #define READ64(x) do { \
120 (x) = (u64)ntohl(*p++) << 32; \
121 (x) |= ntohl(*p++); \
123 #define READTIME(x) do { \
125 (x.tv_sec) = ntohl(*p++); \
126 (x.tv_nsec) = ntohl(*p++); \
128 #define READ_BUF(nbytes) do { \
129 p = xdr_inline_decode(xdr, nbytes); \
131 dprintk("NFSD: %s: reply buffer overflowed in line %d.\n", \
132 __func__, __LINE__); \
137 struct nfs4_cb_compound_hdr
{
139 u32 ident
; /* minorversion 0 only */
150 } nfs_cb_errtbl
[] = {
152 { NFS4ERR_PERM
, EPERM
},
153 { NFS4ERR_NOENT
, ENOENT
},
155 { NFS4ERR_NXIO
, ENXIO
},
156 { NFS4ERR_ACCESS
, EACCES
},
157 { NFS4ERR_EXIST
, EEXIST
},
158 { NFS4ERR_XDEV
, EXDEV
},
159 { NFS4ERR_NOTDIR
, ENOTDIR
},
160 { NFS4ERR_ISDIR
, EISDIR
},
161 { NFS4ERR_INVAL
, EINVAL
},
162 { NFS4ERR_FBIG
, EFBIG
},
163 { NFS4ERR_NOSPC
, ENOSPC
},
164 { NFS4ERR_ROFS
, EROFS
},
165 { NFS4ERR_MLINK
, EMLINK
},
166 { NFS4ERR_NAMETOOLONG
, ENAMETOOLONG
},
167 { NFS4ERR_NOTEMPTY
, ENOTEMPTY
},
168 { NFS4ERR_DQUOT
, EDQUOT
},
169 { NFS4ERR_STALE
, ESTALE
},
170 { NFS4ERR_BADHANDLE
, EBADHANDLE
},
171 { NFS4ERR_BAD_COOKIE
, EBADCOOKIE
},
172 { NFS4ERR_NOTSUPP
, ENOTSUPP
},
173 { NFS4ERR_TOOSMALL
, ETOOSMALL
},
174 { NFS4ERR_SERVERFAULT
, ESERVERFAULT
},
175 { NFS4ERR_BADTYPE
, EBADTYPE
},
176 { NFS4ERR_LOCKED
, EAGAIN
},
177 { NFS4ERR_RESOURCE
, EREMOTEIO
},
178 { NFS4ERR_SYMLINK
, ELOOP
},
179 { NFS4ERR_OP_ILLEGAL
, EOPNOTSUPP
},
180 { NFS4ERR_DEADLOCK
, EDEADLK
},
185 nfs_cb_stat_to_errno(int stat
)
188 for (i
= 0; nfs_cb_errtbl
[i
].stat
!= -1; i
++) {
189 if (nfs_cb_errtbl
[i
].stat
== stat
)
190 return nfs_cb_errtbl
[i
].errno
;
192 /* If we cannot translate the error, the recovery routines should
194 * Note: remaining NFSv4 error codes have values > 10000, so should
195 * not conflict with native Linux error codes.
205 encode_stateid(struct xdr_stream
*xdr
, stateid_t
*sid
)
209 RESERVE_SPACE(sizeof(stateid_t
));
210 WRITE32(sid
->si_generation
);
211 WRITEMEM(&sid
->si_opaque
, sizeof(stateid_opaque_t
));
215 encode_cb_compound_hdr(struct xdr_stream
*xdr
, struct nfs4_cb_compound_hdr
*hdr
)
220 WRITE32(0); /* tag length is always 0 */
221 WRITE32(hdr
->minorversion
);
227 static void encode_cb_nops(struct nfs4_cb_compound_hdr
*hdr
)
229 *hdr
->nops_p
= htonl(hdr
->nops
);
233 encode_cb_recall(struct xdr_stream
*xdr
, struct nfs4_delegation
*dp
,
234 struct nfs4_cb_compound_hdr
*hdr
)
237 int len
= dp
->dl_fh
.fh_size
;
240 WRITE32(OP_CB_RECALL
);
241 encode_stateid(xdr
, &dp
->dl_stateid
);
242 RESERVE_SPACE(8 + (XDR_QUADLEN(len
) << 2));
243 WRITE32(0); /* truncate optimization not implemented */
245 WRITEMEM(&dp
->dl_fh
.fh_base
, len
);
250 encode_cb_sequence(struct xdr_stream
*xdr
, struct nfsd4_callback
*cb
,
251 struct nfs4_cb_compound_hdr
*hdr
)
254 struct nfsd4_session
*ses
= cb
->cb_clp
->cl_cb_session
;
256 if (hdr
->minorversion
== 0)
259 RESERVE_SPACE(1 + NFS4_MAX_SESSIONID_LEN
+ 20);
261 WRITE32(OP_CB_SEQUENCE
);
262 WRITEMEM(ses
->se_sessionid
.data
, NFS4_MAX_SESSIONID_LEN
);
263 WRITE32(ses
->se_cb_seq_nr
);
264 WRITE32(0); /* slotid, always 0 */
265 WRITE32(0); /* highest slotid always 0 */
266 WRITE32(0); /* cachethis always 0 */
267 WRITE32(0); /* FIXME: support referring_call_lists */
272 nfs4_xdr_enc_cb_null(struct rpc_rqst
*req
, __be32
*p
)
274 struct xdr_stream xdrs
, *xdr
= &xdrs
;
276 xdr_init_encode(&xdrs
, &req
->rq_snd_buf
, p
);
282 nfs4_xdr_enc_cb_recall(struct rpc_rqst
*req
, __be32
*p
,
283 struct nfsd4_callback
*cb
)
285 struct xdr_stream xdr
;
286 struct nfs4_delegation
*args
= cb
->cb_op
;
287 struct nfs4_cb_compound_hdr hdr
= {
288 .ident
= cb
->cb_clp
->cl_cb_ident
,
289 .minorversion
= cb
->cb_minorversion
,
292 xdr_init_encode(&xdr
, &req
->rq_snd_buf
, p
);
293 encode_cb_compound_hdr(&xdr
, &hdr
);
294 encode_cb_sequence(&xdr
, cb
, &hdr
);
295 encode_cb_recall(&xdr
, args
, &hdr
);
296 encode_cb_nops(&hdr
);
302 decode_cb_compound_hdr(struct xdr_stream
*xdr
, struct nfs4_cb_compound_hdr
*hdr
){
308 /* We've got no use for the tag; ignore it: */
310 READ_BUF(taglen
+ 4);
311 p
+= XDR_QUADLEN(taglen
);
317 decode_cb_op_hdr(struct xdr_stream
*xdr
, enum nfs_opnum4 expected
)
325 if (op
!= expected
) {
326 dprintk("NFSD: decode_cb_op_hdr: Callback server returned "
327 " operation %d but we issued a request for %d\n",
332 if (nfserr
!= NFS_OK
)
333 return -nfs_cb_stat_to_errno(nfserr
);
338 * Our current back channel implmentation supports a single backchannel
339 * with a single slot.
342 decode_cb_sequence(struct xdr_stream
*xdr
, struct nfsd4_callback
*cb
,
343 struct rpc_rqst
*rqstp
)
345 struct nfsd4_session
*ses
= cb
->cb_clp
->cl_cb_session
;
346 struct nfs4_sessionid id
;
351 if (cb
->cb_minorversion
== 0)
354 status
= decode_cb_op_hdr(xdr
, OP_CB_SEQUENCE
);
359 * If the server returns different values for sessionID, slotID or
360 * sequence number, the server is looney tunes.
362 status
= -ESERVERFAULT
;
364 READ_BUF(NFS4_MAX_SESSIONID_LEN
+ 16);
365 memcpy(id
.data
, p
, NFS4_MAX_SESSIONID_LEN
);
366 p
+= XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN
);
367 if (memcmp(id
.data
, ses
->se_sessionid
.data
, NFS4_MAX_SESSIONID_LEN
)) {
368 dprintk("%s Invalid session id\n", __func__
);
372 if (dummy
!= ses
->se_cb_seq_nr
) {
373 dprintk("%s Invalid sequence number\n", __func__
);
376 READ32(dummy
); /* slotid must be 0 */
378 dprintk("%s Invalid slotid\n", __func__
);
381 /* FIXME: process highest slotid and target highest slotid */
389 nfs4_xdr_dec_cb_null(struct rpc_rqst
*req
, __be32
*p
)
395 nfs4_xdr_dec_cb_recall(struct rpc_rqst
*rqstp
, __be32
*p
,
396 struct nfsd4_callback
*cb
)
398 struct xdr_stream xdr
;
399 struct nfs4_cb_compound_hdr hdr
;
402 xdr_init_decode(&xdr
, &rqstp
->rq_rcv_buf
, p
);
403 status
= decode_cb_compound_hdr(&xdr
, &hdr
);
407 status
= decode_cb_sequence(&xdr
, cb
, rqstp
);
411 status
= decode_cb_op_hdr(&xdr
, OP_CB_RECALL
);
417 * RPC procedure tables
419 #define PROC(proc, call, argtype, restype) \
420 [NFSPROC4_CLNT_##proc] = { \
421 .p_proc = NFSPROC4_CB_##call, \
422 .p_encode = (kxdrproc_t) nfs4_xdr_##argtype, \
423 .p_decode = (kxdrproc_t) nfs4_xdr_##restype, \
424 .p_arglen = NFS4_##argtype##_sz, \
425 .p_replen = NFS4_##restype##_sz, \
426 .p_statidx = NFSPROC4_CB_##call, \
430 static struct rpc_procinfo nfs4_cb_procedures
[] = {
431 PROC(CB_NULL
, NULL
, enc_cb_null
, dec_cb_null
),
432 PROC(CB_RECALL
, COMPOUND
, enc_cb_recall
, dec_cb_recall
),
435 static struct rpc_version nfs_cb_version4
= {
437 * Note on the callback rpc program version number: despite language in rfc
438 * 5661 section 18.36.3 requiring servers to use 4 in this field, the
439 * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
440 * in practice that appears to be what implementations use. The section
441 * 18.36.3 language is expected to be fixed in an erratum.
444 .nrprocs
= ARRAY_SIZE(nfs4_cb_procedures
),
445 .procs
= nfs4_cb_procedures
448 static struct rpc_version
* nfs_cb_version
[] = {
452 static struct rpc_program cb_program
;
454 static struct rpc_stat cb_stats
= {
455 .program
= &cb_program
458 #define NFS4_CALLBACK 0x40000000
459 static struct rpc_program cb_program
= {
461 .number
= NFS4_CALLBACK
,
462 .nrvers
= ARRAY_SIZE(nfs_cb_version
),
463 .version
= nfs_cb_version
,
465 .pipe_dir_name
= "/nfsd4_cb",
468 static int max_cb_time(void)
470 return max(nfsd4_lease
/10, (time_t)1) * HZ
;
473 /* Reference counting, callback cleanup, etc., all look racy as heck.
474 * And why is cl_cb_set an atomic? */
476 int setup_callback_client(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
478 struct rpc_timeout timeparms
= {
479 .to_initval
= max_cb_time(),
482 struct rpc_create_args args
= {
484 .address
= (struct sockaddr
*) &conn
->cb_addr
,
485 .addrsize
= conn
->cb_addrlen
,
486 .timeout
= &timeparms
,
487 .program
= &cb_program
,
489 .authflavor
= clp
->cl_flavor
,
490 .flags
= (RPC_CLNT_CREATE_NOPING
| RPC_CLNT_CREATE_QUIET
),
492 struct rpc_clnt
*client
;
494 if (clp
->cl_minorversion
== 0) {
495 if (!clp
->cl_principal
&& (clp
->cl_flavor
>= RPC_AUTH_GSS_KRB5
))
497 args
.client_name
= clp
->cl_principal
;
498 args
.prognumber
= conn
->cb_prog
,
499 args
.protocol
= XPRT_TRANSPORT_TCP
;
500 clp
->cl_cb_ident
= conn
->cb_ident
;
502 args
.bc_xprt
= conn
->cb_xprt
;
503 args
.prognumber
= clp
->cl_cb_session
->se_cb_prog
;
504 args
.protocol
= XPRT_TRANSPORT_BC_TCP
;
506 /* Create RPC client */
507 client
= rpc_create(&args
);
508 if (IS_ERR(client
)) {
509 dprintk("NFSD: couldn't create callback client: %ld\n",
511 return PTR_ERR(client
);
513 clp
->cl_cb_client
= client
;
518 static void warn_no_callback_path(struct nfs4_client
*clp
, int reason
)
520 dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
521 (int)clp
->cl_name
.len
, clp
->cl_name
.data
, reason
);
524 static void nfsd4_cb_probe_done(struct rpc_task
*task
, void *calldata
)
526 struct nfs4_client
*clp
= container_of(calldata
, struct nfs4_client
, cl_cb_null
);
529 warn_no_callback_path(clp
, task
->tk_status
);
531 atomic_set(&clp
->cl_cb_set
, 1);
534 static const struct rpc_call_ops nfsd4_cb_probe_ops
= {
535 /* XXX: release method to ensure we set the cb channel down if
536 * necessary on early failure? */
537 .rpc_call_done
= nfsd4_cb_probe_done
,
540 static struct rpc_cred
*callback_cred
;
542 int set_callback_cred(void)
546 callback_cred
= rpc_lookup_machine_cred();
552 static struct workqueue_struct
*callback_wq
;
554 static void do_probe_callback(struct nfs4_client
*clp
)
556 struct nfsd4_callback
*cb
= &clp
->cl_cb_null
;
561 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_NULL
];
562 cb
->cb_msg
.rpc_argp
= NULL
;
563 cb
->cb_msg
.rpc_resp
= NULL
;
564 cb
->cb_msg
.rpc_cred
= callback_cred
;
566 cb
->cb_ops
= &nfsd4_cb_probe_ops
;
568 queue_work(callback_wq
, &cb
->cb_work
);
572 * Poke the callback thread to process any updates to the callback
573 * parameters, and send a null probe.
575 void nfsd4_probe_callback(struct nfs4_client
*clp
)
577 set_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_cb_flags
);
578 do_probe_callback(clp
);
581 void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
583 BUG_ON(atomic_read(&clp
->cl_cb_set
));
585 spin_lock(&clp
->cl_lock
);
586 memcpy(&clp
->cl_cb_conn
, conn
, sizeof(struct nfs4_cb_conn
));
587 spin_unlock(&clp
->cl_lock
);
591 * There's currently a single callback channel slot.
592 * If the slot is available, then mark it busy. Otherwise, set the
593 * thread for sleeping on the callback RPC wait queue.
595 static int nfsd41_cb_setup_sequence(struct nfs4_client
*clp
,
596 struct rpc_task
*task
)
598 u32
*ptr
= (u32
*)clp
->cl_cb_session
->se_sessionid
.data
;
601 dprintk("%s: %u:%u:%u:%u\n", __func__
,
602 ptr
[0], ptr
[1], ptr
[2], ptr
[3]);
604 if (test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
605 rpc_sleep_on(&clp
->cl_cb_waitq
, task
, NULL
);
606 dprintk("%s slot is busy\n", __func__
);
611 dprintk("%s status=%d\n", __func__
, status
);
616 * TODO: cb_sequence should support referring call lists, cachethis, multiple
617 * slots, and mark callback channel down on communication errors.
619 static void nfsd4_cb_prepare(struct rpc_task
*task
, void *calldata
)
621 struct nfsd4_callback
*cb
= calldata
;
622 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
623 struct nfs4_client
*clp
= dp
->dl_client
;
624 u32 minorversion
= clp
->cl_minorversion
;
627 cb
->cb_minorversion
= minorversion
;
629 status
= nfsd41_cb_setup_sequence(clp
, task
);
631 if (status
!= -EAGAIN
) {
632 /* terminate rpc task */
633 task
->tk_status
= status
;
634 task
->tk_action
= NULL
;
639 rpc_call_start(task
);
642 static void nfsd4_cb_done(struct rpc_task
*task
, void *calldata
)
644 struct nfsd4_callback
*cb
= calldata
;
645 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
646 struct nfs4_client
*clp
= dp
->dl_client
;
648 dprintk("%s: minorversion=%d\n", __func__
,
649 clp
->cl_minorversion
);
651 if (clp
->cl_minorversion
) {
652 /* No need for lock, access serialized in nfsd4_cb_prepare */
653 ++clp
->cl_cb_session
->se_cb_seq_nr
;
654 clear_bit(0, &clp
->cl_cb_slot_busy
);
655 rpc_wake_up_next(&clp
->cl_cb_waitq
);
656 dprintk("%s: freed slot, new seqid=%d\n", __func__
,
657 clp
->cl_cb_session
->se_cb_seq_nr
);
659 /* We're done looking into the sequence information */
660 task
->tk_msg
.rpc_resp
= NULL
;
665 static void nfsd4_cb_recall_done(struct rpc_task
*task
, void *calldata
)
667 struct nfsd4_callback
*cb
= calldata
;
668 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
669 struct nfs4_client
*clp
= dp
->dl_client
;
670 struct rpc_clnt
*current_rpc_client
= clp
->cl_cb_client
;
672 nfsd4_cb_done(task
, calldata
);
674 if (current_rpc_client
== NULL
) {
675 /* We're shutting down; give up. */
676 /* XXX: err, or is it ok just to fall through
677 * and rpc_restart_call? */
681 switch (task
->tk_status
) {
685 case -NFS4ERR_BAD_STATEID
:
686 /* Race: client probably got cb_recall
687 * before open reply granting delegation */
690 /* Network partition? */
691 atomic_set(&clp
->cl_cb_set
, 0);
692 warn_no_callback_path(clp
, task
->tk_status
);
693 if (current_rpc_client
!= task
->tk_client
) {
694 /* queue a callback on the new connection: */
695 atomic_inc(&dp
->dl_count
);
700 if (dp
->dl_retries
--) {
701 rpc_delay(task
, 2*HZ
);
703 rpc_restart_call_prepare(task
);
706 atomic_set(&clp
->cl_cb_set
, 0);
707 warn_no_callback_path(clp
, task
->tk_status
);
711 static void nfsd4_cb_recall_release(void *calldata
)
713 struct nfsd4_callback
*cb
= calldata
;
714 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
716 nfs4_put_delegation(dp
);
719 static const struct rpc_call_ops nfsd4_cb_recall_ops
= {
720 .rpc_call_prepare
= nfsd4_cb_prepare
,
721 .rpc_call_done
= nfsd4_cb_recall_done
,
722 .rpc_release
= nfsd4_cb_recall_release
,
725 int nfsd4_create_callback_queue(void)
727 callback_wq
= create_singlethread_workqueue("nfsd4_callbacks");
733 void nfsd4_destroy_callback_queue(void)
735 destroy_workqueue(callback_wq
);
738 /* must be called under the state lock */
739 void nfsd4_shutdown_callback(struct nfs4_client
*clp
)
741 set_bit(NFSD4_CLIENT_KILL
, &clp
->cl_cb_flags
);
743 * Note this won't actually result in a null callback;
744 * instead, nfsd4_do_callback_rpc() will detect the killed
745 * client, destroy the rpc client, and stop:
747 do_probe_callback(clp
);
748 flush_workqueue(callback_wq
);
751 void nfsd4_release_cb(struct nfsd4_callback
*cb
)
753 if (cb
->cb_ops
->rpc_release
)
754 cb
->cb_ops
->rpc_release(cb
);
757 void nfsd4_process_cb_update(struct nfsd4_callback
*cb
)
759 struct nfs4_cb_conn conn
;
760 struct nfs4_client
*clp
= cb
->cb_clp
;
764 * This is either an update, or the client dying; in either case,
765 * kill the old client:
767 if (clp
->cl_cb_client
) {
768 rpc_shutdown_client(clp
->cl_cb_client
);
769 clp
->cl_cb_client
= NULL
;
771 if (test_bit(NFSD4_CLIENT_KILL
, &clp
->cl_cb_flags
))
773 spin_lock(&clp
->cl_lock
);
775 * Only serialized callback code is allowed to clear these
776 * flags; main nfsd code can only set them:
778 BUG_ON(!clp
->cl_cb_flags
);
779 clear_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_cb_flags
);
780 memcpy(&conn
, &cb
->cb_clp
->cl_cb_conn
, sizeof(struct nfs4_cb_conn
));
781 spin_unlock(&clp
->cl_lock
);
783 err
= setup_callback_client(clp
, &conn
);
785 warn_no_callback_path(clp
, err
);
788 void nfsd4_do_callback_rpc(struct work_struct
*w
)
790 struct nfsd4_callback
*cb
= container_of(w
, struct nfsd4_callback
, cb_work
);
791 struct nfs4_client
*clp
= cb
->cb_clp
;
792 struct rpc_clnt
*clnt
;
794 if (clp
->cl_cb_flags
)
795 nfsd4_process_cb_update(cb
);
797 clnt
= clp
->cl_cb_client
;
799 /* Callback channel broken, or client killed; give up: */
800 nfsd4_release_cb(cb
);
803 rpc_call_async(clnt
, &cb
->cb_msg
, RPC_TASK_SOFT
| RPC_TASK_SOFTCONN
,
807 void nfsd4_cb_recall(struct nfs4_delegation
*dp
)
809 struct nfsd4_callback
*cb
= &dp
->dl_recall
;
813 cb
->cb_clp
= dp
->dl_client
;
814 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_RECALL
];
815 cb
->cb_msg
.rpc_argp
= cb
;
816 cb
->cb_msg
.rpc_resp
= cb
;
817 cb
->cb_msg
.rpc_cred
= callback_cred
;
819 cb
->cb_ops
= &nfsd4_cb_recall_ops
;
822 queue_work(callback_wq
, &dp
->dl_recall
.cb_work
);