nfsd4: remove unused deleg dprintk's.
[linux-2.6.git] / fs / nfsd / nfs4callback.c
1 /*
2  *  Copyright (c) 2001 The Regents of the University of Michigan.
3  *  All rights reserved.
4  *
5  *  Kendrick Smith <kmsmith@umich.edu>
6  *  Andy Adamson <andros@umich.edu>
7  *
8  *  Redistribution and use in source and binary forms, with or without
9  *  modification, are permitted provided that the following conditions
10  *  are met:
11  *
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.
20  *
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.
32  */
33
34 #include <linux/sunrpc/clnt.h>
35 #include <linux/sunrpc/svc_xprt.h>
36 #include <linux/slab.h>
37 #include "nfsd.h"
38 #include "state.h"
39
40 #define NFSDDBG_FACILITY                NFSDDBG_PROC
41
42 #define NFSPROC4_CB_NULL 0
43 #define NFSPROC4_CB_COMPOUND 1
44
45 /* Index of predefined Linux callback client operations */
46
47 enum {
48         NFSPROC4_CLNT_CB_NULL = 0,
49         NFSPROC4_CLNT_CB_RECALL,
50         NFSPROC4_CLNT_CB_SEQUENCE,
51 };
52
53 #define NFS4_MAXTAGLEN          20
54
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)
63
64 #define op_enc_sz                       1
65 #define op_dec_sz                       2
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 +            \
71                                         enc_nfs4_fh_sz)
72
73 #define NFS4_dec_cb_recall_sz           (cb_compound_dec_hdr_sz  +      \
74                                         cb_sequence_dec_sz +            \
75                                         op_dec_sz)
76
77 struct nfs4_cb_compound_hdr {
78         /* args */
79         u32             ident;  /* minorversion 0 only */
80         u32             nops;
81         __be32          *nops_p;
82         u32             minorversion;
83         /* res */
84         int             status;
85 };
86
87 /*
88  * Handle decode buffer overflows out-of-line.
89  */
90 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
91 {
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);
95 }
96
97 static __be32 *xdr_encode_empty_array(__be32 *p)
98 {
99         *p++ = xdr_zero;
100         return p;
101 }
102
103 /*
104  * Encode/decode NFSv4 CB basic data types
105  *
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
109  * 1 Protocol"
110  */
111
112 /*
113  *      nfs_cb_opnum4
114  *
115  *      enum nfs_cb_opnum4 {
116  *              OP_CB_GETATTR           = 3,
117  *                ...
118  *      };
119  */
120 enum nfs_cb_opnum4 {
121         OP_CB_GETATTR                   = 3,
122         OP_CB_RECALL                    = 4,
123         OP_CB_LAYOUTRECALL              = 5,
124         OP_CB_NOTIFY                    = 6,
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,
129         OP_CB_SEQUENCE                  = 11,
130         OP_CB_WANTS_CANCELLED           = 12,
131         OP_CB_NOTIFY_LOCK               = 13,
132         OP_CB_NOTIFY_DEVICEID           = 14,
133         OP_CB_ILLEGAL                   = 10044
134 };
135
136 static void encode_nfs_cb_opnum4(struct xdr_stream *xdr, enum nfs_cb_opnum4 op)
137 {
138         __be32 *p;
139
140         p = xdr_reserve_space(xdr, 4);
141         *p = cpu_to_be32(op);
142 }
143
144 /*
145  * nfs_fh4
146  *
147  *      typedef opaque nfs_fh4<NFS4_FHSIZE>;
148  */
149 static void encode_nfs_fh4(struct xdr_stream *xdr, const struct knfsd_fh *fh)
150 {
151         u32 length = fh->fh_size;
152         __be32 *p;
153
154         BUG_ON(length > NFS4_FHSIZE);
155         p = xdr_reserve_space(xdr, 4 + length);
156         xdr_encode_opaque(p, &fh->fh_base, length);
157 }
158
159 /*
160  * stateid4
161  *
162  *      struct stateid4 {
163  *              uint32_t        seqid;
164  *              opaque          other[12];
165  *      };
166  */
167 static void encode_stateid4(struct xdr_stream *xdr, const stateid_t *sid)
168 {
169         __be32 *p;
170
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);
174 }
175
176 /*
177  * sessionid4
178  *
179  *      typedef opaque sessionid4[NFS4_SESSIONID_SIZE];
180  */
181 static void encode_sessionid4(struct xdr_stream *xdr,
182                               const struct nfsd4_session *session)
183 {
184         __be32 *p;
185
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);
189 }
190
191 /*
192  * nfsstat4
193  */
194 static const struct {
195         int stat;
196         int errno;
197 } nfs_cb_errtbl[] = {
198         { NFS4_OK,              0               },
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        },
228         { -1,                   -EIO            }
229 };
230
231 /*
232  * If we cannot translate the error, the recovery routines should
233  * handle it.
234  *
235  * Note: remaining NFSv4 error codes have values > 10000, so should
236  * not conflict with native Linux error codes.
237  */
238 static int nfs_cb_stat_to_errno(int status)
239 {
240         int i;
241
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;
245         }
246
247         dprintk("NFSD: Unrecognized NFS CB status value: %u\n", status);
248         return -status;
249 }
250
251 static int decode_cb_op_status(struct xdr_stream *xdr, enum nfs_opnum4 expected,
252                                enum nfsstat4 *status)
253 {
254         __be32 *p;
255         u32 op;
256
257         p = xdr_inline_decode(xdr, 4 + 4);
258         if (unlikely(p == NULL))
259                 goto out_overflow;
260         op = be32_to_cpup(p++);
261         if (unlikely(op != expected))
262                 goto out_unexpected;
263         *status = be32_to_cpup(p);
264         return 0;
265 out_overflow:
266         print_overflow_msg(__func__, xdr);
267         return -EIO;
268 out_unexpected:
269         dprintk("NFSD: Callback server returned operation %d but "
270                 "we issued a request for %d\n", op, expected);
271         return -EIO;
272 }
273
274 /*
275  * CB_COMPOUND4args
276  *
277  *      struct CB_COMPOUND4args {
278  *              utf8str_cs      tag;
279  *              uint32_t        minorversion;
280  *              uint32_t        callback_ident;
281  *              nfs_cb_argop4   argarray<>;
282  *      };
283 */
284 static void encode_cb_compound4args(struct xdr_stream *xdr,
285                                     struct nfs4_cb_compound_hdr *hdr)
286 {
287         __be32 * p;
288
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);
293
294         hdr->nops_p = p;
295         *p = cpu_to_be32(hdr->nops);            /* argarray element count */
296 }
297
298 /*
299  * Update argarray element count
300  */
301 static void encode_cb_nops(struct nfs4_cb_compound_hdr *hdr)
302 {
303         BUG_ON(hdr->nops > NFS4_MAX_BACK_CHANNEL_OPS);
304         *hdr->nops_p = cpu_to_be32(hdr->nops);
305 }
306
307 /*
308  * CB_COMPOUND4res
309  *
310  *      struct CB_COMPOUND4res {
311  *              nfsstat4        status;
312  *              utf8str_cs      tag;
313  *              nfs_cb_resop4   resarray<>;
314  *      };
315  */
316 static int decode_cb_compound4res(struct xdr_stream *xdr,
317                                   struct nfs4_cb_compound_hdr *hdr)
318 {
319         u32 length;
320         __be32 *p;
321
322         p = xdr_inline_decode(xdr, 4 + 4);
323         if (unlikely(p == NULL))
324                 goto out_overflow;
325         hdr->status = be32_to_cpup(p++);
326         /* Ignore the tag */
327         length = be32_to_cpup(p++);
328         p = xdr_inline_decode(xdr, length + 4);
329         if (unlikely(p == NULL))
330                 goto out_overflow;
331         hdr->nops = be32_to_cpup(p);
332         return 0;
333 out_overflow:
334         print_overflow_msg(__func__, xdr);
335         return -EIO;
336 }
337
338 /*
339  * CB_RECALL4args
340  *
341  *      struct CB_RECALL4args {
342  *              stateid4        stateid;
343  *              bool            truncate;
344  *              nfs_fh4         fh;
345  *      };
346  */
347 static void encode_cb_recall4args(struct xdr_stream *xdr,
348                                   const struct nfs4_delegation *dp,
349                                   struct nfs4_cb_compound_hdr *hdr)
350 {
351         __be32 *p;
352
353         encode_nfs_cb_opnum4(xdr, OP_CB_RECALL);
354         encode_stateid4(xdr, &dp->dl_stateid);
355
356         p = xdr_reserve_space(xdr, 4);
357         *p++ = xdr_zero;                        /* truncate */
358
359         encode_nfs_fh4(xdr, &dp->dl_fh);
360
361         hdr->nops++;
362 }
363
364 /*
365  * CB_SEQUENCE4args
366  *
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<>;
374  *      };
375  */
376 static void encode_cb_sequence4args(struct xdr_stream *xdr,
377                                     const struct nfsd4_callback *cb,
378                                     struct nfs4_cb_compound_hdr *hdr)
379 {
380         struct nfsd4_session *session = cb->cb_clp->cl_cb_session;
381         __be32 *p;
382
383         if (hdr->minorversion == 0)
384                 return;
385
386         encode_nfs_cb_opnum4(xdr, OP_CB_SEQUENCE);
387         encode_sessionid4(xdr, session);
388
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 */
395
396         hdr->nops++;
397 }
398
399 /*
400  * CB_SEQUENCE4resok
401  *
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;
408  *      };
409  *
410  *      union CB_SEQUENCE4res switch (nfsstat4 csr_status) {
411  *      case NFS4_OK:
412  *              CB_SEQUENCE4resok       csr_resok4;
413  *      default:
414  *              void;
415  *      };
416  *
417  * Our current back channel implmentation supports a single backchannel
418  * with a single slot.
419  */
420 static int decode_cb_sequence4resok(struct xdr_stream *xdr,
421                                     struct nfsd4_callback *cb)
422 {
423         struct nfsd4_session *session = cb->cb_clp->cl_cb_session;
424         struct nfs4_sessionid id;
425         int status;
426         __be32 *p;
427         u32 dummy;
428
429         status = -ESERVERFAULT;
430
431         /*
432          * If the server returns different values for sessionID, slotID or
433          * sequence number, the server is looney tunes.
434          */
435         p = xdr_inline_decode(xdr, NFS4_MAX_SESSIONID_LEN + 4 + 4);
436         if (unlikely(p == NULL))
437                 goto out_overflow;
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__);
442                 goto out;
443         }
444         p += XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN);
445
446         dummy = be32_to_cpup(p++);
447         if (dummy != session->se_cb_seq_nr) {
448                 dprintk("NFS: %s Invalid sequence number\n", __func__);
449                 goto out;
450         }
451
452         dummy = be32_to_cpup(p++);
453         if (dummy != 0) {
454                 dprintk("NFS: %s Invalid slotid\n", __func__);
455                 goto out;
456         }
457
458         /*
459          * FIXME: process highest slotid and target highest slotid
460          */
461         status = 0;
462 out:
463         return status;
464 out_overflow:
465         print_overflow_msg(__func__, xdr);
466         return -EIO;
467 }
468
469 static int decode_cb_sequence4res(struct xdr_stream *xdr,
470                                   struct nfsd4_callback *cb)
471 {
472         enum nfsstat4 nfserr;
473         int status;
474
475         if (cb->cb_minorversion == 0)
476                 return 0;
477
478         status = decode_cb_op_status(xdr, OP_CB_SEQUENCE, &nfserr);
479         if (unlikely(status))
480                 goto out;
481         if (unlikely(nfserr != NFS4_OK))
482                 goto out_default;
483         status = decode_cb_sequence4resok(xdr, cb);
484 out:
485         return status;
486 out_default:
487         return nfs_cb_stat_to_errno(nfserr);
488 }
489
490 /*
491  * NFSv4.0 and NFSv4.1 XDR encode functions
492  *
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
496  * Protocol".
497  */
498
499 /*
500  * NB: Without this zero space reservation, callbacks over krb5p fail
501  */
502 static void nfs4_xdr_enc_cb_null(struct rpc_rqst *req, struct xdr_stream *xdr,
503                                  void *__unused)
504 {
505         xdr_reserve_space(xdr, 0);
506 }
507
508 /*
509  * 20.2. Operation 4: CB_RECALL - Recall a Delegation
510  */
511 static void nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, struct xdr_stream *xdr,
512                                    const struct nfsd4_callback *cb)
513 {
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,
518         };
519
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);
524 }
525
526
527 /*
528  * NFSv4.0 and NFSv4.1 XDR decode functions
529  *
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
533  * Protocol".
534  */
535
536 static int nfs4_xdr_dec_cb_null(struct rpc_rqst *req, struct xdr_stream *xdr,
537                                 void *__unused)
538 {
539         return 0;
540 }
541
542 /*
543  * 20.2. Operation 4: CB_RECALL - Recall a Delegation
544  */
545 static int nfs4_xdr_dec_cb_recall(struct rpc_rqst *rqstp,
546                                   struct xdr_stream *xdr,
547                                   struct nfsd4_callback *cb)
548 {
549         struct nfs4_cb_compound_hdr hdr;
550         enum nfsstat4 nfserr;
551         int status;
552
553         status = decode_cb_compound4res(xdr, &hdr);
554         if (unlikely(status))
555                 goto out;
556
557         if (cb != NULL) {
558                 status = decode_cb_sequence4res(xdr, cb);
559                 if (unlikely(status))
560                         goto out;
561         }
562
563         status = decode_cb_op_status(xdr, OP_CB_RECALL, &nfserr);
564         if (unlikely(status))
565                 goto out;
566         if (unlikely(nfserr != NFS4_OK))
567                 status = nfs_cb_stat_to_errno(nfserr);
568 out:
569         return status;
570 }
571
572 /*
573  * RPC procedure tables
574  */
575 #define PROC(proc, call, argtype, restype)                              \
576 [NFSPROC4_CLNT_##proc] = {                                              \
577         .p_proc    = NFSPROC4_CB_##call,                                \
578         .p_encode  = (kxdreproc_t)nfs4_xdr_enc_##argtype,               \
579         .p_decode  = (kxdrdproc_t)nfs4_xdr_dec_##restype,               \
580         .p_arglen  = NFS4_enc_##argtype##_sz,                           \
581         .p_replen  = NFS4_dec_##restype##_sz,                           \
582         .p_statidx = NFSPROC4_CB_##call,                                \
583         .p_name    = #proc,                                             \
584 }
585
586 static struct rpc_procinfo nfs4_cb_procedures[] = {
587         PROC(CB_NULL,   NULL,           cb_null,        cb_null),
588         PROC(CB_RECALL, COMPOUND,       cb_recall,      cb_recall),
589 };
590
591 static struct rpc_version nfs_cb_version4 = {
592 /*
593  * Note on the callback rpc program version number: despite language in rfc
594  * 5661 section 18.36.3 requiring servers to use 4 in this field, the
595  * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
596  * in practice that appears to be what implementations use.  The section
597  * 18.36.3 language is expected to be fixed in an erratum.
598  */
599         .number                 = 1,
600         .nrprocs                = ARRAY_SIZE(nfs4_cb_procedures),
601         .procs                  = nfs4_cb_procedures
602 };
603
604 static struct rpc_version *nfs_cb_version[] = {
605         &nfs_cb_version4,
606 };
607
608 static struct rpc_program cb_program;
609
610 static struct rpc_stat cb_stats = {
611         .program                = &cb_program
612 };
613
614 #define NFS4_CALLBACK 0x40000000
615 static struct rpc_program cb_program = {
616         .name                   = "nfs4_cb",
617         .number                 = NFS4_CALLBACK,
618         .nrvers                 = ARRAY_SIZE(nfs_cb_version),
619         .version                = nfs_cb_version,
620         .stats                  = &cb_stats,
621         .pipe_dir_name          = "/nfsd4_cb",
622 };
623
624 static int max_cb_time(void)
625 {
626         return max(nfsd4_lease/10, (time_t)1) * HZ;
627 }
628
629
630 static int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *conn, struct nfsd4_session *ses)
631 {
632         struct rpc_timeout      timeparms = {
633                 .to_initval     = max_cb_time(),
634                 .to_retries     = 0,
635         };
636         struct rpc_create_args args = {
637                 .net            = &init_net,
638                 .address        = (struct sockaddr *) &conn->cb_addr,
639                 .addrsize       = conn->cb_addrlen,
640                 .saddress       = (struct sockaddr *) &conn->cb_saddr,
641                 .timeout        = &timeparms,
642                 .program        = &cb_program,
643                 .version        = 0,
644                 .authflavor     = clp->cl_flavor,
645                 .flags          = (RPC_CLNT_CREATE_NOPING | RPC_CLNT_CREATE_QUIET),
646         };
647         struct rpc_clnt *client;
648
649         if (clp->cl_minorversion == 0) {
650                 if (!clp->cl_principal && (clp->cl_flavor >= RPC_AUTH_GSS_KRB5))
651                         return -EINVAL;
652                 args.client_name = clp->cl_principal;
653                 args.prognumber = conn->cb_prog,
654                 args.protocol = XPRT_TRANSPORT_TCP;
655                 clp->cl_cb_ident = conn->cb_ident;
656         } else {
657                 if (!conn->cb_xprt)
658                         return -EINVAL;
659                 clp->cl_cb_conn.cb_xprt = conn->cb_xprt;
660                 clp->cl_cb_session = ses;
661                 args.bc_xprt = conn->cb_xprt;
662                 args.prognumber = clp->cl_cb_session->se_cb_prog;
663                 args.protocol = XPRT_TRANSPORT_BC_TCP;
664         }
665         /* Create RPC client */
666         client = rpc_create(&args);
667         if (IS_ERR(client)) {
668                 dprintk("NFSD: couldn't create callback client: %ld\n",
669                         PTR_ERR(client));
670                 return PTR_ERR(client);
671         }
672         clp->cl_cb_client = client;
673         return 0;
674
675 }
676
677 static void warn_no_callback_path(struct nfs4_client *clp, int reason)
678 {
679         dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
680                 (int)clp->cl_name.len, clp->cl_name.data, reason);
681 }
682
683 static void nfsd4_mark_cb_down(struct nfs4_client *clp, int reason)
684 {
685         clp->cl_cb_state = NFSD4_CB_DOWN;
686         warn_no_callback_path(clp, reason);
687 }
688
689 static void nfsd4_cb_probe_done(struct rpc_task *task, void *calldata)
690 {
691         struct nfs4_client *clp = container_of(calldata, struct nfs4_client, cl_cb_null);
692
693         if (task->tk_status)
694                 nfsd4_mark_cb_down(clp, task->tk_status);
695         else
696                 clp->cl_cb_state = NFSD4_CB_UP;
697 }
698
699 static const struct rpc_call_ops nfsd4_cb_probe_ops = {
700         /* XXX: release method to ensure we set the cb channel down if
701          * necessary on early failure? */
702         .rpc_call_done = nfsd4_cb_probe_done,
703 };
704
705 static struct rpc_cred *callback_cred;
706
707 int set_callback_cred(void)
708 {
709         if (callback_cred)
710                 return 0;
711         callback_cred = rpc_lookup_machine_cred();
712         if (!callback_cred)
713                 return -ENOMEM;
714         return 0;
715 }
716
717 static struct workqueue_struct *callback_wq;
718
719 static void run_nfsd4_cb(struct nfsd4_callback *cb)
720 {
721         queue_work(callback_wq, &cb->cb_work);
722 }
723
724 static void do_probe_callback(struct nfs4_client *clp)
725 {
726         struct nfsd4_callback *cb = &clp->cl_cb_null;
727
728         cb->cb_op = NULL;
729         cb->cb_clp = clp;
730
731         cb->cb_msg.rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_NULL];
732         cb->cb_msg.rpc_argp = NULL;
733         cb->cb_msg.rpc_resp = NULL;
734         cb->cb_msg.rpc_cred = callback_cred;
735
736         cb->cb_ops = &nfsd4_cb_probe_ops;
737
738         run_nfsd4_cb(cb);
739 }
740
741 /*
742  * Poke the callback thread to process any updates to the callback
743  * parameters, and send a null probe.
744  */
745 void nfsd4_probe_callback(struct nfs4_client *clp)
746 {
747         /* XXX: atomicity?  Also, should we be using cl_cb_flags? */
748         clp->cl_cb_state = NFSD4_CB_UNKNOWN;
749         set_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_cb_flags);
750         do_probe_callback(clp);
751 }
752
753 void nfsd4_probe_callback_sync(struct nfs4_client *clp)
754 {
755         nfsd4_probe_callback(clp);
756         flush_workqueue(callback_wq);
757 }
758
759 void nfsd4_change_callback(struct nfs4_client *clp, struct nfs4_cb_conn *conn)
760 {
761         clp->cl_cb_state = NFSD4_CB_UNKNOWN;
762         spin_lock(&clp->cl_lock);
763         memcpy(&clp->cl_cb_conn, conn, sizeof(struct nfs4_cb_conn));
764         spin_unlock(&clp->cl_lock);
765 }
766
767 /*
768  * There's currently a single callback channel slot.
769  * If the slot is available, then mark it busy.  Otherwise, set the
770  * thread for sleeping on the callback RPC wait queue.
771  */
772 static bool nfsd41_cb_get_slot(struct nfs4_client *clp, struct rpc_task *task)
773 {
774         if (test_and_set_bit(0, &clp->cl_cb_slot_busy) != 0) {
775                 rpc_sleep_on(&clp->cl_cb_waitq, task, NULL);
776                 dprintk("%s slot is busy\n", __func__);
777                 return false;
778         }
779         return true;
780 }
781
782 /*
783  * TODO: cb_sequence should support referring call lists, cachethis, multiple
784  * slots, and mark callback channel down on communication errors.
785  */
786 static void nfsd4_cb_prepare(struct rpc_task *task, void *calldata)
787 {
788         struct nfsd4_callback *cb = calldata;
789         struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
790         struct nfs4_client *clp = dp->dl_client;
791         u32 minorversion = clp->cl_minorversion;
792
793         cb->cb_minorversion = minorversion;
794         if (minorversion) {
795                 if (!nfsd41_cb_get_slot(clp, task))
796                         return;
797         }
798         spin_lock(&clp->cl_lock);
799         if (list_empty(&cb->cb_per_client)) {
800                 /* This is the first call, not a restart */
801                 cb->cb_done = false;
802                 list_add(&cb->cb_per_client, &clp->cl_callbacks);
803         }
804         spin_unlock(&clp->cl_lock);
805         rpc_call_start(task);
806 }
807
808 static void nfsd4_cb_done(struct rpc_task *task, void *calldata)
809 {
810         struct nfsd4_callback *cb = calldata;
811         struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
812         struct nfs4_client *clp = dp->dl_client;
813
814         dprintk("%s: minorversion=%d\n", __func__,
815                 clp->cl_minorversion);
816
817         if (clp->cl_minorversion) {
818                 /* No need for lock, access serialized in nfsd4_cb_prepare */
819                 ++clp->cl_cb_session->se_cb_seq_nr;
820                 clear_bit(0, &clp->cl_cb_slot_busy);
821                 rpc_wake_up_next(&clp->cl_cb_waitq);
822                 dprintk("%s: freed slot, new seqid=%d\n", __func__,
823                         clp->cl_cb_session->se_cb_seq_nr);
824
825                 /* We're done looking into the sequence information */
826                 task->tk_msg.rpc_resp = NULL;
827         }
828 }
829
830
831 static void nfsd4_cb_recall_done(struct rpc_task *task, void *calldata)
832 {
833         struct nfsd4_callback *cb = calldata;
834         struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
835         struct nfs4_client *clp = dp->dl_client;
836         struct rpc_clnt *current_rpc_client = clp->cl_cb_client;
837
838         nfsd4_cb_done(task, calldata);
839
840         if (current_rpc_client != task->tk_client) {
841                 /* We're shutting down or changing cl_cb_client; leave
842                  * it to nfsd4_process_cb_update to restart the call if
843                  * necessary. */
844                 return;
845         }
846
847         if (cb->cb_done)
848                 return;
849         switch (task->tk_status) {
850         case 0:
851                 cb->cb_done = true;
852                 return;
853         case -EBADHANDLE:
854         case -NFS4ERR_BAD_STATEID:
855                 /* Race: client probably got cb_recall
856                  * before open reply granting delegation */
857                 break;
858         default:
859                 /* Network partition? */
860                 nfsd4_mark_cb_down(clp, task->tk_status);
861         }
862         if (dp->dl_retries--) {
863                 rpc_delay(task, 2*HZ);
864                 task->tk_status = 0;
865                 rpc_restart_call_prepare(task);
866                 return;
867         }
868         nfsd4_mark_cb_down(clp, task->tk_status);
869         cb->cb_done = true;
870 }
871
872 static void nfsd4_cb_recall_release(void *calldata)
873 {
874         struct nfsd4_callback *cb = calldata;
875         struct nfs4_client *clp = cb->cb_clp;
876         struct nfs4_delegation *dp = container_of(cb, struct nfs4_delegation, dl_recall);
877
878         if (cb->cb_done) {
879                 spin_lock(&clp->cl_lock);
880                 list_del(&cb->cb_per_client);
881                 spin_unlock(&clp->cl_lock);
882                 nfs4_put_delegation(dp);
883         }
884 }
885
886 static const struct rpc_call_ops nfsd4_cb_recall_ops = {
887         .rpc_call_prepare = nfsd4_cb_prepare,
888         .rpc_call_done = nfsd4_cb_recall_done,
889         .rpc_release = nfsd4_cb_recall_release,
890 };
891
892 int nfsd4_create_callback_queue(void)
893 {
894         callback_wq = create_singlethread_workqueue("nfsd4_callbacks");
895         if (!callback_wq)
896                 return -ENOMEM;
897         return 0;
898 }
899
900 void nfsd4_destroy_callback_queue(void)
901 {
902         destroy_workqueue(callback_wq);
903 }
904
905 /* must be called under the state lock */
906 void nfsd4_shutdown_callback(struct nfs4_client *clp)
907 {
908         set_bit(NFSD4_CLIENT_KILL, &clp->cl_cb_flags);
909         /*
910          * Note this won't actually result in a null callback;
911          * instead, nfsd4_do_callback_rpc() will detect the killed
912          * client, destroy the rpc client, and stop:
913          */
914         do_probe_callback(clp);
915         flush_workqueue(callback_wq);
916 }
917
918 static void nfsd4_release_cb(struct nfsd4_callback *cb)
919 {
920         if (cb->cb_ops->rpc_release)
921                 cb->cb_ops->rpc_release(cb);
922 }
923
924 /* requires cl_lock: */
925 static struct nfsd4_conn * __nfsd4_find_backchannel(struct nfs4_client *clp)
926 {
927         struct nfsd4_session *s;
928         struct nfsd4_conn *c;
929
930         list_for_each_entry(s, &clp->cl_sessions, se_perclnt) {
931                 list_for_each_entry(c, &s->se_conns, cn_persession) {
932                         if (c->cn_flags & NFS4_CDFC4_BACK)
933                                 return c;
934                 }
935         }
936         return NULL;
937 }
938
939 static void nfsd4_process_cb_update(struct nfsd4_callback *cb)
940 {
941         struct nfs4_cb_conn conn;
942         struct nfs4_client *clp = cb->cb_clp;
943         struct nfsd4_session *ses = NULL;
944         struct nfsd4_conn *c;
945         int err;
946
947         /*
948          * This is either an update, or the client dying; in either case,
949          * kill the old client:
950          */
951         if (clp->cl_cb_client) {
952                 rpc_shutdown_client(clp->cl_cb_client);
953                 clp->cl_cb_client = NULL;
954         }
955         if (clp->cl_cb_conn.cb_xprt) {
956                 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
957                 clp->cl_cb_conn.cb_xprt = NULL;
958         }
959         if (test_bit(NFSD4_CLIENT_KILL, &clp->cl_cb_flags))
960                 return;
961         spin_lock(&clp->cl_lock);
962         /*
963          * Only serialized callback code is allowed to clear these
964          * flags; main nfsd code can only set them:
965          */
966         BUG_ON(!clp->cl_cb_flags);
967         clear_bit(NFSD4_CLIENT_CB_UPDATE, &clp->cl_cb_flags);
968         memcpy(&conn, &cb->cb_clp->cl_cb_conn, sizeof(struct nfs4_cb_conn));
969         c = __nfsd4_find_backchannel(clp);
970         if (c) {
971                 svc_xprt_get(c->cn_xprt);
972                 conn.cb_xprt = c->cn_xprt;
973                 ses = c->cn_session;
974         }
975         spin_unlock(&clp->cl_lock);
976
977         err = setup_callback_client(clp, &conn, ses);
978         if (err) {
979                 warn_no_callback_path(clp, err);
980                 return;
981         }
982         /* Yay, the callback channel's back! Restart any callbacks: */
983         list_for_each_entry(cb, &clp->cl_callbacks, cb_per_client)
984                 run_nfsd4_cb(cb);
985 }
986
987 void nfsd4_do_callback_rpc(struct work_struct *w)
988 {
989         struct nfsd4_callback *cb = container_of(w, struct nfsd4_callback, cb_work);
990         struct nfs4_client *clp = cb->cb_clp;
991         struct rpc_clnt *clnt;
992
993         if (clp->cl_cb_flags)
994                 nfsd4_process_cb_update(cb);
995
996         clnt = clp->cl_cb_client;
997         if (!clnt) {
998                 /* Callback channel broken, or client killed; give up: */
999                 nfsd4_release_cb(cb);
1000                 return;
1001         }
1002         rpc_call_async(clnt, &cb->cb_msg, RPC_TASK_SOFT | RPC_TASK_SOFTCONN,
1003                         cb->cb_ops, cb);
1004 }
1005
1006 void nfsd4_cb_recall(struct nfs4_delegation *dp)
1007 {
1008         struct nfsd4_callback *cb = &dp->dl_recall;
1009         struct nfs4_client *clp = dp->dl_client;
1010
1011         dp->dl_retries = 1;
1012         cb->cb_op = dp;
1013         cb->cb_clp = clp;
1014         cb->cb_msg.rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_RECALL];
1015         cb->cb_msg.rpc_argp = cb;
1016         cb->cb_msg.rpc_resp = cb;
1017         cb->cb_msg.rpc_cred = callback_cred;
1018
1019         cb->cb_ops = &nfsd4_cb_recall_ops;
1020         dp->dl_retries = 1;
1021
1022         INIT_LIST_HEAD(&cb->cb_per_client);
1023         cb->cb_done = true;
1024
1025         run_nfsd4_cb(&dp->dl_recall);
1026 }