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 .protocol
= XPRT_TRANSPORT_TCP
,
485 .address
= (struct sockaddr
*) &conn
->cb_addr
,
486 .addrsize
= conn
->cb_addrlen
,
487 .timeout
= &timeparms
,
488 .program
= &cb_program
,
489 .prognumber
= conn
->cb_prog
,
491 .authflavor
= clp
->cl_flavor
,
492 .flags
= (RPC_CLNT_CREATE_NOPING
| RPC_CLNT_CREATE_QUIET
),
493 .client_name
= clp
->cl_principal
,
495 struct rpc_clnt
*client
;
497 if (!clp
->cl_principal
&& (clp
->cl_flavor
>= RPC_AUTH_GSS_KRB5
))
499 if (conn
->cb_minorversion
) {
500 args
.bc_xprt
= conn
->cb_xprt
;
501 args
.prognumber
= clp
->cl_cb_session
->se_cb_prog
;
502 args
.protocol
= XPRT_TRANSPORT_BC_TCP
;
504 /* Create RPC client */
505 client
= rpc_create(&args
);
506 if (IS_ERR(client
)) {
507 dprintk("NFSD: couldn't create callback client: %ld\n",
509 return PTR_ERR(client
);
511 clp
->cl_cb_ident
= conn
->cb_ident
;
512 clp
->cl_cb_client
= client
;
517 static void warn_no_callback_path(struct nfs4_client
*clp
, int reason
)
519 dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
520 (int)clp
->cl_name
.len
, clp
->cl_name
.data
, reason
);
523 static void nfsd4_cb_probe_done(struct rpc_task
*task
, void *calldata
)
525 struct nfs4_client
*clp
= container_of(calldata
, struct nfs4_client
, cl_cb_null
);
528 warn_no_callback_path(clp
, task
->tk_status
);
530 atomic_set(&clp
->cl_cb_set
, 1);
533 static const struct rpc_call_ops nfsd4_cb_probe_ops
= {
534 /* XXX: release method to ensure we set the cb channel down if
535 * necessary on early failure? */
536 .rpc_call_done
= nfsd4_cb_probe_done
,
539 static struct rpc_cred
*callback_cred
;
541 int set_callback_cred(void)
545 callback_cred
= rpc_lookup_machine_cred();
551 static struct workqueue_struct
*callback_wq
;
553 static void do_probe_callback(struct nfs4_client
*clp
)
555 struct nfsd4_callback
*cb
= &clp
->cl_cb_null
;
560 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_NULL
];
561 cb
->cb_msg
.rpc_argp
= NULL
;
562 cb
->cb_msg
.rpc_resp
= NULL
;
563 cb
->cb_msg
.rpc_cred
= callback_cred
;
565 cb
->cb_ops
= &nfsd4_cb_probe_ops
;
567 queue_work(callback_wq
, &cb
->cb_work
);
571 * Poke the callback thread to process any updates to the callback
572 * parameters, and send a null probe.
574 void nfsd4_probe_callback(struct nfs4_client
*clp
)
576 set_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_cb_flags
);
577 do_probe_callback(clp
);
580 void nfsd4_change_callback(struct nfs4_client
*clp
, struct nfs4_cb_conn
*conn
)
582 BUG_ON(atomic_read(&clp
->cl_cb_set
));
584 spin_lock(&clp
->cl_lock
);
585 memcpy(&clp
->cl_cb_conn
, conn
, sizeof(struct nfs4_cb_conn
));
586 spin_unlock(&clp
->cl_lock
);
590 * There's currently a single callback channel slot.
591 * If the slot is available, then mark it busy. Otherwise, set the
592 * thread for sleeping on the callback RPC wait queue.
594 static int nfsd41_cb_setup_sequence(struct nfs4_client
*clp
,
595 struct rpc_task
*task
)
597 u32
*ptr
= (u32
*)clp
->cl_cb_session
->se_sessionid
.data
;
600 dprintk("%s: %u:%u:%u:%u\n", __func__
,
601 ptr
[0], ptr
[1], ptr
[2], ptr
[3]);
603 if (test_and_set_bit(0, &clp
->cl_cb_slot_busy
) != 0) {
604 rpc_sleep_on(&clp
->cl_cb_waitq
, task
, NULL
);
605 dprintk("%s slot is busy\n", __func__
);
610 dprintk("%s status=%d\n", __func__
, status
);
615 * TODO: cb_sequence should support referring call lists, cachethis, multiple
616 * slots, and mark callback channel down on communication errors.
618 static void nfsd4_cb_prepare(struct rpc_task
*task
, void *calldata
)
620 struct nfsd4_callback
*cb
= calldata
;
621 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
622 struct nfs4_client
*clp
= dp
->dl_client
;
623 u32 minorversion
= clp
->cl_cb_conn
.cb_minorversion
;
626 cb
->cb_minorversion
= minorversion
;
628 status
= nfsd41_cb_setup_sequence(clp
, task
);
630 if (status
!= -EAGAIN
) {
631 /* terminate rpc task */
632 task
->tk_status
= status
;
633 task
->tk_action
= NULL
;
638 rpc_call_start(task
);
641 static void nfsd4_cb_done(struct rpc_task
*task
, void *calldata
)
643 struct nfsd4_callback
*cb
= calldata
;
644 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
645 struct nfs4_client
*clp
= dp
->dl_client
;
647 dprintk("%s: minorversion=%d\n", __func__
,
648 clp
->cl_cb_conn
.cb_minorversion
);
650 if (clp
->cl_cb_conn
.cb_minorversion
) {
651 /* No need for lock, access serialized in nfsd4_cb_prepare */
652 ++clp
->cl_cb_session
->se_cb_seq_nr
;
653 clear_bit(0, &clp
->cl_cb_slot_busy
);
654 rpc_wake_up_next(&clp
->cl_cb_waitq
);
655 dprintk("%s: freed slot, new seqid=%d\n", __func__
,
656 clp
->cl_cb_session
->se_cb_seq_nr
);
658 /* We're done looking into the sequence information */
659 task
->tk_msg
.rpc_resp
= NULL
;
664 static void nfsd4_cb_recall_done(struct rpc_task
*task
, void *calldata
)
666 struct nfsd4_callback
*cb
= calldata
;
667 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
668 struct nfs4_client
*clp
= dp
->dl_client
;
669 struct rpc_clnt
*current_rpc_client
= clp
->cl_cb_client
;
671 nfsd4_cb_done(task
, calldata
);
673 if (current_rpc_client
== NULL
) {
674 /* We're shutting down; give up. */
675 /* XXX: err, or is it ok just to fall through
676 * and rpc_restart_call? */
680 switch (task
->tk_status
) {
684 case -NFS4ERR_BAD_STATEID
:
685 /* Race: client probably got cb_recall
686 * before open reply granting delegation */
689 /* Network partition? */
690 atomic_set(&clp
->cl_cb_set
, 0);
691 warn_no_callback_path(clp
, task
->tk_status
);
692 if (current_rpc_client
!= task
->tk_client
) {
693 /* queue a callback on the new connection: */
694 atomic_inc(&dp
->dl_count
);
699 if (dp
->dl_retries
--) {
700 rpc_delay(task
, 2*HZ
);
702 rpc_restart_call_prepare(task
);
705 atomic_set(&clp
->cl_cb_set
, 0);
706 warn_no_callback_path(clp
, task
->tk_status
);
710 static void nfsd4_cb_recall_release(void *calldata
)
712 struct nfsd4_callback
*cb
= calldata
;
713 struct nfs4_delegation
*dp
= container_of(cb
, struct nfs4_delegation
, dl_recall
);
715 nfs4_put_delegation(dp
);
718 static const struct rpc_call_ops nfsd4_cb_recall_ops
= {
719 .rpc_call_prepare
= nfsd4_cb_prepare
,
720 .rpc_call_done
= nfsd4_cb_recall_done
,
721 .rpc_release
= nfsd4_cb_recall_release
,
724 int nfsd4_create_callback_queue(void)
726 callback_wq
= create_singlethread_workqueue("nfsd4_callbacks");
732 void nfsd4_destroy_callback_queue(void)
734 destroy_workqueue(callback_wq
);
737 /* must be called under the state lock */
738 void nfsd4_shutdown_callback(struct nfs4_client
*clp
)
740 set_bit(NFSD4_CLIENT_KILL
, &clp
->cl_cb_flags
);
742 * Note this won't actually result in a null callback;
743 * instead, nfsd4_do_callback_rpc() will detect the killed
744 * client, destroy the rpc client, and stop:
746 do_probe_callback(clp
);
747 flush_workqueue(callback_wq
);
750 void nfsd4_release_cb(struct nfsd4_callback
*cb
)
752 if (cb
->cb_ops
->rpc_release
)
753 cb
->cb_ops
->rpc_release(cb
);
756 void nfsd4_process_cb_update(struct nfsd4_callback
*cb
)
758 struct nfs4_cb_conn conn
;
759 struct nfs4_client
*clp
= cb
->cb_clp
;
763 * This is either an update, or the client dying; in either case,
764 * kill the old client:
766 if (clp
->cl_cb_client
) {
767 rpc_shutdown_client(clp
->cl_cb_client
);
768 clp
->cl_cb_client
= NULL
;
770 if (test_bit(NFSD4_CLIENT_KILL
, &clp
->cl_cb_flags
))
772 spin_lock(&clp
->cl_lock
);
774 * Only serialized callback code is allowed to clear these
775 * flags; main nfsd code can only set them:
777 BUG_ON(!clp
->cl_cb_flags
);
778 clear_bit(NFSD4_CLIENT_CB_UPDATE
, &clp
->cl_cb_flags
);
779 memcpy(&conn
, &cb
->cb_clp
->cl_cb_conn
, sizeof(struct nfs4_cb_conn
));
780 spin_unlock(&clp
->cl_lock
);
782 err
= setup_callback_client(clp
, &conn
);
784 warn_no_callback_path(clp
, err
);
787 void nfsd4_do_callback_rpc(struct work_struct
*w
)
789 struct nfsd4_callback
*cb
= container_of(w
, struct nfsd4_callback
, cb_work
);
790 struct nfs4_client
*clp
= cb
->cb_clp
;
791 struct rpc_clnt
*clnt
;
793 if (clp
->cl_cb_flags
)
794 nfsd4_process_cb_update(cb
);
796 clnt
= clp
->cl_cb_client
;
798 /* Callback channel broken, or client killed; give up: */
799 nfsd4_release_cb(cb
);
802 rpc_call_async(clnt
, &cb
->cb_msg
, RPC_TASK_SOFT
| RPC_TASK_SOFTCONN
,
806 void nfsd4_cb_recall(struct nfs4_delegation
*dp
)
808 struct nfsd4_callback
*cb
= &dp
->dl_recall
;
812 cb
->cb_clp
= dp
->dl_client
;
813 cb
->cb_msg
.rpc_proc
= &nfs4_cb_procedures
[NFSPROC4_CLNT_CB_RECALL
];
814 cb
->cb_msg
.rpc_argp
= cb
;
815 cb
->cb_msg
.rpc_resp
= cb
;
816 cb
->cb_msg
.rpc_cred
= callback_cred
;
818 cb
->cb_ops
= &nfsd4_cb_recall_ops
;
821 queue_work(callback_wq
, &dp
->dl_recall
.cb_work
);