blob: eb78e7e2207740c5a3cf36e4d098ef970c88be73 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/sunrpc/clnt.h>
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -050035#include <linux/sunrpc/svc_xprt.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090036#include <linux/slab.h>
Boaz Harrosh9a74af22009-12-03 20:30:56 +020037#include "nfsd.h"
38#include "state.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40#define NFSDDBG_FACILITY NFSDDBG_PROC
41
42#define NFSPROC4_CB_NULL 0
43#define NFSPROC4_CB_COMPOUND 1
Andy Adamson38524ab2009-09-10 12:25:59 +030044#define NFS4_STATEID_SIZE 16
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Linus Torvalds1da177e2005-04-16 15:20:36 -070046/* Index of predefined Linux callback client operations */
47
48enum {
Benny Halevy4be36ca2009-09-10 12:25:46 +030049 NFSPROC4_CLNT_CB_NULL = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 NFSPROC4_CLNT_CB_RECALL,
Andy Adamson38524ab2009-09-10 12:25:59 +030051 NFSPROC4_CLNT_CB_SEQUENCE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070052};
53
54enum nfs_cb_opnum4 {
55 OP_CB_RECALL = 4,
Andy Adamson38524ab2009-09-10 12:25:59 +030056 OP_CB_SEQUENCE = 11,
Linus Torvalds1da177e2005-04-16 15:20:36 -070057};
58
59#define NFS4_MAXTAGLEN 20
60
61#define NFS4_enc_cb_null_sz 0
62#define NFS4_dec_cb_null_sz 0
63#define cb_compound_enc_hdr_sz 4
64#define cb_compound_dec_hdr_sz (3 + (NFS4_MAXTAGLEN >> 2))
Andy Adamson38524ab2009-09-10 12:25:59 +030065#define sessionid_sz (NFS4_MAX_SESSIONID_LEN >> 2)
66#define cb_sequence_enc_sz (sessionid_sz + 4 + \
67 1 /* no referring calls list yet */)
68#define cb_sequence_dec_sz (op_dec_sz + sessionid_sz + 4)
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#define op_enc_sz 1
71#define op_dec_sz 2
72#define enc_nfs4_fh_sz (1 + (NFS4_FHSIZE >> 2))
Benny Halevy0ac68d12007-07-17 04:04:37 -070073#define enc_stateid_sz (NFS4_STATEID_SIZE >> 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#define NFS4_enc_cb_recall_sz (cb_compound_enc_hdr_sz + \
Andy Adamson38524ab2009-09-10 12:25:59 +030075 cb_sequence_enc_sz + \
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 1 + enc_stateid_sz + \
77 enc_nfs4_fh_sz)
78
79#define NFS4_dec_cb_recall_sz (cb_compound_dec_hdr_sz + \
Andy Adamson38524ab2009-09-10 12:25:59 +030080 cb_sequence_dec_sz + \
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 op_dec_sz)
82
83/*
84* Generic encode routines from fs/nfs/nfs4xdr.c
85*/
Al Virof00f3282006-10-19 23:29:01 -070086static inline __be32 *
87xdr_writemem(__be32 *p, const void *ptr, int nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
89 int tmp = XDR_QUADLEN(nbytes);
90 if (!tmp)
91 return p;
92 p[tmp-1] = 0;
93 memcpy(p, ptr, nbytes);
94 return p + tmp;
95}
96
97#define WRITE32(n) *p++ = htonl(n)
98#define WRITEMEM(ptr,nbytes) do { \
99 p = xdr_writemem(p, ptr, nbytes); \
100} while (0)
101#define RESERVE_SPACE(nbytes) do { \
102 p = xdr_reserve_space(xdr, nbytes); \
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700103 if (!p) dprintk("NFSD: RESERVE_SPACE(%d) failed in function %s\n", (int) (nbytes), __func__); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 BUG_ON(!p); \
105} while (0)
106
107/*
108 * Generic decode routines from fs/nfs/nfs4xdr.c
109 */
110#define DECODE_TAIL \
111 status = 0; \
112out: \
113 return status; \
114xdr_error: \
115 dprintk("NFSD: xdr error! (%s:%d)\n", __FILE__, __LINE__); \
116 status = -EIO; \
117 goto out
118
119#define READ32(x) (x) = ntohl(*p++)
120#define READ64(x) do { \
121 (x) = (u64)ntohl(*p++) << 32; \
122 (x) |= ntohl(*p++); \
123} while (0)
124#define READTIME(x) do { \
125 p++; \
126 (x.tv_sec) = ntohl(*p++); \
127 (x.tv_nsec) = ntohl(*p++); \
128} while (0)
129#define READ_BUF(nbytes) do { \
130 p = xdr_inline_decode(xdr, nbytes); \
131 if (!p) { \
Greg Banks3e3b4802006-10-02 02:17:41 -0700132 dprintk("NFSD: %s: reply buffer overflowed in line %d.\n", \
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700133 __func__, __LINE__); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 return -EIO; \
135 } \
136} while (0)
137
138struct nfs4_cb_compound_hdr {
Andy Adamson38524ab2009-09-10 12:25:59 +0300139 /* args */
140 u32 ident; /* minorversion 0 only */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 u32 nops;
Andy Adamsonef52bff2009-06-16 04:20:50 +0300142 __be32 *nops_p;
Andy Adamsonab52ae62009-06-16 04:20:53 +0300143 u32 minorversion;
Andy Adamson38524ab2009-09-10 12:25:59 +0300144 /* res */
145 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 u32 taglen;
Andy Adamsonef52bff2009-06-16 04:20:50 +0300147 char *tag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148};
149
150static struct {
151int stat;
152int errno;
153} nfs_cb_errtbl[] = {
154 { NFS4_OK, 0 },
155 { NFS4ERR_PERM, EPERM },
156 { NFS4ERR_NOENT, ENOENT },
157 { NFS4ERR_IO, EIO },
158 { NFS4ERR_NXIO, ENXIO },
159 { NFS4ERR_ACCESS, EACCES },
160 { NFS4ERR_EXIST, EEXIST },
161 { NFS4ERR_XDEV, EXDEV },
162 { NFS4ERR_NOTDIR, ENOTDIR },
163 { NFS4ERR_ISDIR, EISDIR },
164 { NFS4ERR_INVAL, EINVAL },
165 { NFS4ERR_FBIG, EFBIG },
166 { NFS4ERR_NOSPC, ENOSPC },
167 { NFS4ERR_ROFS, EROFS },
168 { NFS4ERR_MLINK, EMLINK },
169 { NFS4ERR_NAMETOOLONG, ENAMETOOLONG },
170 { NFS4ERR_NOTEMPTY, ENOTEMPTY },
171 { NFS4ERR_DQUOT, EDQUOT },
172 { NFS4ERR_STALE, ESTALE },
173 { NFS4ERR_BADHANDLE, EBADHANDLE },
174 { NFS4ERR_BAD_COOKIE, EBADCOOKIE },
175 { NFS4ERR_NOTSUPP, ENOTSUPP },
176 { NFS4ERR_TOOSMALL, ETOOSMALL },
177 { NFS4ERR_SERVERFAULT, ESERVERFAULT },
178 { NFS4ERR_BADTYPE, EBADTYPE },
179 { NFS4ERR_LOCKED, EAGAIN },
180 { NFS4ERR_RESOURCE, EREMOTEIO },
181 { NFS4ERR_SYMLINK, ELOOP },
182 { NFS4ERR_OP_ILLEGAL, EOPNOTSUPP },
183 { NFS4ERR_DEADLOCK, EDEADLK },
184 { -1, EIO }
185};
186
187static int
188nfs_cb_stat_to_errno(int stat)
189{
190 int i;
191 for (i = 0; nfs_cb_errtbl[i].stat != -1; i++) {
192 if (nfs_cb_errtbl[i].stat == stat)
193 return nfs_cb_errtbl[i].errno;
194 }
195 /* If we cannot translate the error, the recovery routines should
196 * handle it.
197 * Note: remaining NFSv4 error codes have values > 10000, so should
198 * not conflict with native Linux error codes.
199 */
200 return stat;
201}
202
203/*
204 * XDR encode
205 */
206
Andy Adamsonef52bff2009-06-16 04:20:50 +0300207static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208encode_cb_compound_hdr(struct xdr_stream *xdr, struct nfs4_cb_compound_hdr *hdr)
209{
Al Virof00f3282006-10-19 23:29:01 -0700210 __be32 * p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
212 RESERVE_SPACE(16);
213 WRITE32(0); /* tag length is always 0 */
Andy Adamsonab52ae62009-06-16 04:20:53 +0300214 WRITE32(hdr->minorversion);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 WRITE32(hdr->ident);
Andy Adamsonef52bff2009-06-16 04:20:50 +0300216 hdr->nops_p = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 WRITE32(hdr->nops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218}
219
Andy Adamsonef52bff2009-06-16 04:20:50 +0300220static void encode_cb_nops(struct nfs4_cb_compound_hdr *hdr)
221{
222 *hdr->nops_p = htonl(hdr->nops);
223}
224
225static void
226encode_cb_recall(struct xdr_stream *xdr, struct nfs4_delegation *dp,
227 struct nfs4_cb_compound_hdr *hdr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
Al Virof00f3282006-10-19 23:29:01 -0700229 __be32 *p;
J. Bruce Fieldsb53d40c2009-05-01 19:50:00 -0400230 int len = dp->dl_fh.fh_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
J. Bruce Fieldsb53d40c2009-05-01 19:50:00 -0400232 RESERVE_SPACE(12+sizeof(dp->dl_stateid) + len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 WRITE32(OP_CB_RECALL);
J. Bruce Fieldsb53d40c2009-05-01 19:50:00 -0400234 WRITE32(dp->dl_stateid.si_generation);
235 WRITEMEM(&dp->dl_stateid.si_opaque, sizeof(stateid_opaque_t));
J. Bruce Fields6707bd32009-05-01 19:57:46 -0400236 WRITE32(0); /* truncate optimization not implemented */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 WRITE32(len);
J. Bruce Fieldsb53d40c2009-05-01 19:50:00 -0400238 WRITEMEM(&dp->dl_fh.fh_base, len);
Andy Adamsonef52bff2009-06-16 04:20:50 +0300239 hdr->nops++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240}
241
Benny Halevy2af73582009-09-10 12:26:51 +0300242static void
243encode_cb_sequence(struct xdr_stream *xdr, struct nfsd4_cb_sequence *args,
244 struct nfs4_cb_compound_hdr *hdr)
245{
246 __be32 *p;
247
248 if (hdr->minorversion == 0)
249 return;
250
251 RESERVE_SPACE(1 + NFS4_MAX_SESSIONID_LEN + 20);
252
253 WRITE32(OP_CB_SEQUENCE);
254 WRITEMEM(args->cbs_clp->cl_sessionid.data, NFS4_MAX_SESSIONID_LEN);
255 WRITE32(args->cbs_clp->cl_cb_seq_nr);
256 WRITE32(0); /* slotid, always 0 */
257 WRITE32(0); /* highest slotid always 0 */
258 WRITE32(0); /* cachethis always 0 */
259 WRITE32(0); /* FIXME: support referring_call_lists */
260 hdr->nops++;
261}
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263static int
Al Virof00f3282006-10-19 23:29:01 -0700264nfs4_xdr_enc_cb_null(struct rpc_rqst *req, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
266 struct xdr_stream xdrs, *xdr = &xdrs;
267
268 xdr_init_encode(&xdrs, &req->rq_snd_buf, p);
269 RESERVE_SPACE(0);
270 return 0;
271}
272
273static int
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300274nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, __be32 *p,
275 struct nfs4_rpc_args *rpc_args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
277 struct xdr_stream xdr;
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300278 struct nfs4_delegation *args = rpc_args->args_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 struct nfs4_cb_compound_hdr hdr = {
J. Bruce Fieldsb53d40c2009-05-01 19:50:00 -0400280 .ident = args->dl_ident,
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300281 .minorversion = rpc_args->args_seq.cbs_minorversion,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 };
283
284 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
285 encode_cb_compound_hdr(&xdr, &hdr);
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300286 encode_cb_sequence(&xdr, &rpc_args->args_seq, &hdr);
Andy Adamsonef52bff2009-06-16 04:20:50 +0300287 encode_cb_recall(&xdr, args, &hdr);
288 encode_cb_nops(&hdr);
289 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290}
291
292
293static int
294decode_cb_compound_hdr(struct xdr_stream *xdr, struct nfs4_cb_compound_hdr *hdr){
Al Virof00f3282006-10-19 23:29:01 -0700295 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
297 READ_BUF(8);
298 READ32(hdr->status);
299 READ32(hdr->taglen);
300 READ_BUF(hdr->taglen + 4);
301 hdr->tag = (char *)p;
302 p += XDR_QUADLEN(hdr->taglen);
303 READ32(hdr->nops);
304 return 0;
305}
306
307static int
308decode_cb_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
309{
Al Virof00f3282006-10-19 23:29:01 -0700310 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 u32 op;
312 int32_t nfserr;
313
314 READ_BUF(8);
315 READ32(op);
316 if (op != expected) {
317 dprintk("NFSD: decode_cb_op_hdr: Callback server returned "
318 " operation %d but we issued a request for %d\n",
319 op, expected);
320 return -EIO;
321 }
322 READ32(nfserr);
323 if (nfserr != NFS_OK)
324 return -nfs_cb_stat_to_errno(nfserr);
325 return 0;
326}
327
Benny Halevy2af73582009-09-10 12:26:51 +0300328/*
329 * Our current back channel implmentation supports a single backchannel
330 * with a single slot.
331 */
332static int
333decode_cb_sequence(struct xdr_stream *xdr, struct nfsd4_cb_sequence *res,
334 struct rpc_rqst *rqstp)
335{
336 struct nfs4_sessionid id;
337 int status;
338 u32 dummy;
339 __be32 *p;
340
341 if (res->cbs_minorversion == 0)
342 return 0;
343
344 status = decode_cb_op_hdr(xdr, OP_CB_SEQUENCE);
345 if (status)
346 return status;
347
348 /*
349 * If the server returns different values for sessionID, slotID or
350 * sequence number, the server is looney tunes.
351 */
352 status = -ESERVERFAULT;
353
354 READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);
355 memcpy(id.data, p, NFS4_MAX_SESSIONID_LEN);
356 p += XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN);
357 if (memcmp(id.data, res->cbs_clp->cl_sessionid.data,
358 NFS4_MAX_SESSIONID_LEN)) {
359 dprintk("%s Invalid session id\n", __func__);
360 goto out;
361 }
362 READ32(dummy);
363 if (dummy != res->cbs_clp->cl_cb_seq_nr) {
364 dprintk("%s Invalid sequence number\n", __func__);
365 goto out;
366 }
367 READ32(dummy); /* slotid must be 0 */
368 if (dummy != 0) {
369 dprintk("%s Invalid slotid\n", __func__);
370 goto out;
371 }
372 /* FIXME: process highest slotid and target highest slotid */
373 status = 0;
374out:
375 return status;
376}
377
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379static int
Al Virof00f3282006-10-19 23:29:01 -0700380nfs4_xdr_dec_cb_null(struct rpc_rqst *req, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
382 return 0;
383}
384
385static int
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300386nfs4_xdr_dec_cb_recall(struct rpc_rqst *rqstp, __be32 *p,
387 struct nfsd4_cb_sequence *seq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
389 struct xdr_stream xdr;
390 struct nfs4_cb_compound_hdr hdr;
391 int status;
392
393 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
394 status = decode_cb_compound_hdr(&xdr, &hdr);
395 if (status)
396 goto out;
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300397 if (seq) {
398 status = decode_cb_sequence(&xdr, seq, rqstp);
399 if (status)
400 goto out;
401 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 status = decode_cb_op_hdr(&xdr, OP_CB_RECALL);
403out:
404 return status;
405}
406
407/*
408 * RPC procedure tables
409 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410#define PROC(proc, call, argtype, restype) \
411[NFSPROC4_CLNT_##proc] = { \
412 .p_proc = NFSPROC4_CB_##call, \
413 .p_encode = (kxdrproc_t) nfs4_xdr_##argtype, \
414 .p_decode = (kxdrproc_t) nfs4_xdr_##restype, \
Chuck Lever2bea90d2007-03-29 16:47:53 -0400415 .p_arglen = NFS4_##argtype##_sz, \
416 .p_replen = NFS4_##restype##_sz, \
Chuck Levercc0175c2006-03-20 13:44:22 -0500417 .p_statidx = NFSPROC4_CB_##call, \
418 .p_name = #proc, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419}
420
NeilBrownfd39ca92005-06-23 22:04:03 -0700421static struct rpc_procinfo nfs4_cb_procedures[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 PROC(CB_NULL, NULL, enc_cb_null, dec_cb_null),
423 PROC(CB_RECALL, COMPOUND, enc_cb_recall, dec_cb_recall),
424};
425
NeilBrownfd39ca92005-06-23 22:04:03 -0700426static struct rpc_version nfs_cb_version4 = {
J. Bruce Fieldsb7299f42010-05-14 17:57:35 -0400427/*
428 * Note on the callback rpc program version number: despite language in rfc
429 * 5661 section 18.36.3 requiring servers to use 4 in this field, the
430 * official xdr descriptions for both 4.0 and 4.1 specify version 1, and
431 * in practice that appears to be what implementations use. The section
432 * 18.36.3 language is expected to be fixed in an erratum.
433 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 .number = 1,
Tobias Klausere8c96f82006-03-24 03:15:34 -0800435 .nrprocs = ARRAY_SIZE(nfs4_cb_procedures),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 .procs = nfs4_cb_procedures
437};
438
439static struct rpc_version * nfs_cb_version[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 &nfs_cb_version4,
441};
442
Olga Kornievskaiaff7d9752008-03-28 16:04:56 -0400443static struct rpc_program cb_program;
444
445static struct rpc_stat cb_stats = {
446 .program = &cb_program
447};
448
449#define NFS4_CALLBACK 0x40000000
450static struct rpc_program cb_program = {
451 .name = "nfs4_cb",
452 .number = NFS4_CALLBACK,
453 .nrvers = ARRAY_SIZE(nfs_cb_version),
454 .version = nfs_cb_version,
455 .stats = &cb_stats,
Olga Kornievskaia61054b12008-12-23 16:19:00 -0500456 .pipe_dir_name = "/nfsd4_cb",
Olga Kornievskaiaff7d9752008-03-28 16:04:56 -0400457};
458
J. Bruce Fields595947a2009-03-05 17:18:10 -0500459static int max_cb_time(void)
460{
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -0500461 return max(nfsd4_lease/10, (time_t)1) * HZ;
J. Bruce Fields595947a2009-03-05 17:18:10 -0500462}
463
J. Bruce Fields2b47eec2007-07-27 18:06:50 -0400464/* Reference counting, callback cleanup, etc., all look racy as heck.
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500465 * And why is cl_cb_set an atomic? */
J. Bruce Fields2b47eec2007-07-27 18:06:50 -0400466
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500467int setup_callback_client(struct nfs4_client *clp, struct nfs4_cb_conn *cb)
J. Bruce Fields2b47eec2007-07-27 18:06:50 -0400468{
Chuck Leverae5c7942006-08-22 20:06:21 -0400469 struct rpc_timeout timeparms = {
J. Bruce Fields595947a2009-03-05 17:18:10 -0500470 .to_initval = max_cb_time(),
471 .to_retries = 0,
Chuck Leverae5c7942006-08-22 20:06:21 -0400472 };
Chuck Leverae5c7942006-08-22 20:06:21 -0400473 struct rpc_create_args args = {
Alexandros Batsakis3ddc8bf2009-09-10 12:27:21 +0300474 .protocol = XPRT_TRANSPORT_TCP,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -0400475 .address = (struct sockaddr *) &cb->cb_addr,
476 .addrsize = cb->cb_addrlen,
Chuck Leverae5c7942006-08-22 20:06:21 -0400477 .timeout = &timeparms,
Olga Kornievskaiaff7d9752008-03-28 16:04:56 -0400478 .program = &cb_program,
Benny Halevyd5b337b2008-09-28 09:21:26 +0300479 .prognumber = cb->cb_prog,
J. Bruce Fieldsb7299f42010-05-14 17:57:35 -0400480 .version = 0,
Olga Kornievskaia61054b12008-12-23 16:19:00 -0500481 .authflavor = clp->cl_flavor,
Olga Kornievskaiab6b61522008-06-09 16:51:31 -0400482 .flags = (RPC_CLNT_CREATE_NOPING | RPC_CLNT_CREATE_QUIET),
Olga Kornievskaia608207e2008-12-23 16:17:40 -0500483 .client_name = clp->cl_principal,
Chuck Leverae5c7942006-08-22 20:06:21 -0400484 };
J. Bruce Fields63c86712007-10-25 19:00:26 -0400485 struct rpc_clnt *client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
J. Bruce Fields418cd202009-02-22 15:52:13 -0800487 if (!clp->cl_principal && (clp->cl_flavor >= RPC_AUTH_GSS_KRB5))
J. Bruce Fieldse1cab5a2009-02-23 10:45:27 -0800488 return -EINVAL;
Alexandros Batsakis3ddc8bf2009-09-10 12:27:21 +0300489 if (cb->cb_minorversion) {
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500490 args.bc_xprt = cb->cb_xprt;
Alexandros Batsakis3ddc8bf2009-09-10 12:27:21 +0300491 args.protocol = XPRT_TRANSPORT_BC_TCP;
492 }
Chuck Leverae5c7942006-08-22 20:06:21 -0400493 /* Create RPC client */
J. Bruce Fields63c86712007-10-25 19:00:26 -0400494 client = rpc_create(&args);
J. Bruce Fieldse1cab5a2009-02-23 10:45:27 -0800495 if (IS_ERR(client)) {
J. Bruce Fieldsa601cae2009-02-22 16:43:45 -0800496 dprintk("NFSD: couldn't create callback client: %ld\n",
497 PTR_ERR(client));
J. Bruce Fieldse1cab5a2009-02-23 10:45:27 -0800498 return PTR_ERR(client);
499 }
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500500 nfsd4_set_callback_client(clp, client);
J. Bruce Fieldse1cab5a2009-02-23 10:45:27 -0800501 return 0;
J. Bruce Fieldsa601cae2009-02-22 16:43:45 -0800502
503}
504
J. Bruce Fieldsecdd03b2009-02-23 19:35:22 -0800505static void warn_no_callback_path(struct nfs4_client *clp, int reason)
506{
507 dprintk("NFSD: warning: no callback path to client %.*s: error %d\n",
508 (int)clp->cl_name.len, clp->cl_name.data, reason);
509}
510
J. Bruce Fieldse300a632009-03-05 15:01:11 -0500511static void nfsd4_cb_probe_done(struct rpc_task *task, void *calldata)
512{
513 struct nfs4_client *clp = calldata;
514
515 if (task->tk_status)
516 warn_no_callback_path(clp, task->tk_status);
517 else
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500518 atomic_set(&clp->cl_cb_set, 1);
J. Bruce Fieldse300a632009-03-05 15:01:11 -0500519}
520
521static const struct rpc_call_ops nfsd4_cb_probe_ops = {
522 .rpc_call_done = nfsd4_cb_probe_done,
523};
524
J. Bruce Fields80fc0152009-09-15 18:07:35 -0400525static struct rpc_cred *callback_cred;
J. Bruce Fields3cef9ab2009-02-23 21:42:10 -0800526
J. Bruce Fields80fc0152009-09-15 18:07:35 -0400527int set_callback_cred(void)
528{
J. Bruce Fields8d75da82010-03-03 16:13:29 -0500529 if (callback_cred)
530 return 0;
J. Bruce Fields80fc0152009-09-15 18:07:35 -0400531 callback_cred = rpc_lookup_machine_cred();
532 if (!callback_cred)
533 return -ENOMEM;
534 return 0;
J. Bruce Fields3cef9ab2009-02-23 21:42:10 -0800535}
536
J. Bruce Fields80fc0152009-09-15 18:07:35 -0400537
J. Bruce Fieldse300a632009-03-05 15:01:11 -0500538void do_probe_callback(struct nfs4_client *clp)
J. Bruce Fieldsa601cae2009-02-22 16:43:45 -0800539{
J. Bruce Fieldsa601cae2009-02-22 16:43:45 -0800540 struct rpc_message msg = {
541 .rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_NULL],
542 .rpc_argp = clp,
J. Bruce Fields80fc0152009-09-15 18:07:35 -0400543 .rpc_cred = callback_cred
J. Bruce Fieldsa601cae2009-02-22 16:43:45 -0800544 };
J. Bruce Fieldsa601cae2009-02-22 16:43:45 -0800545 int status;
546
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500547 status = rpc_call_async(clp->cl_cb_client, &msg,
Chuck Lever58255a42010-02-24 13:48:06 -0800548 RPC_TASK_SOFT | RPC_TASK_SOFTCONN,
J. Bruce Fieldse300a632009-03-05 15:01:11 -0500549 &nfsd4_cb_probe_ops, (void *)clp);
J. Bruce Fields9045b4b2010-02-21 17:53:04 -0800550 if (status)
J. Bruce Fieldsecdd03b2009-02-23 19:35:22 -0800551 warn_no_callback_path(clp, status);
J. Bruce Fields63c86712007-10-25 19:00:26 -0400552}
553
554/*
555 * Set up the callback client and put a NFSPROC4_CB_NULL on the wire...
556 */
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500557void nfsd4_probe_callback(struct nfs4_client *clp, struct nfs4_cb_conn *cb)
J. Bruce Fields63c86712007-10-25 19:00:26 -0400558{
J. Bruce Fieldsecdd03b2009-02-23 19:35:22 -0800559 int status;
J. Bruce Fields63c86712007-10-25 19:00:26 -0400560
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500561 BUG_ON(atomic_read(&clp->cl_cb_set));
J. Bruce Fields63c86712007-10-25 19:00:26 -0400562
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500563 status = setup_callback_client(clp, cb);
J. Bruce Fieldsecdd03b2009-02-23 19:35:22 -0800564 if (status) {
565 warn_no_callback_path(clp, status);
566 return;
567 }
J. Bruce Fieldse300a632009-03-05 15:01:11 -0500568 do_probe_callback(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569}
570
Ricardo Labiaga2a1d1b52009-09-10 12:26:38 +0300571/*
572 * There's currently a single callback channel slot.
573 * If the slot is available, then mark it busy. Otherwise, set the
574 * thread for sleeping on the callback RPC wait queue.
575 */
576static int nfsd41_cb_setup_sequence(struct nfs4_client *clp,
577 struct rpc_task *task)
578{
579 struct nfs4_rpc_args *args = task->tk_msg.rpc_argp;
580 u32 *ptr = (u32 *)clp->cl_sessionid.data;
581 int status = 0;
582
583 dprintk("%s: %u:%u:%u:%u\n", __func__,
584 ptr[0], ptr[1], ptr[2], ptr[3]);
585
586 if (test_and_set_bit(0, &clp->cl_cb_slot_busy) != 0) {
587 rpc_sleep_on(&clp->cl_cb_waitq, task, NULL);
588 dprintk("%s slot is busy\n", __func__);
589 status = -EAGAIN;
590 goto out;
591 }
592
593 /*
594 * We'll need the clp during XDR encoding and decoding,
595 * and the sequence during decoding to verify the reply
596 */
597 args->args_seq.cbs_clp = clp;
598 task->tk_msg.rpc_resp = &args->args_seq;
599
600out:
601 dprintk("%s status=%d\n", __func__, status);
602 return status;
603}
604
605/*
606 * TODO: cb_sequence should support referring call lists, cachethis, multiple
607 * slots, and mark callback channel down on communication errors.
608 */
609static void nfsd4_cb_prepare(struct rpc_task *task, void *calldata)
610{
611 struct nfs4_delegation *dp = calldata;
612 struct nfs4_client *clp = dp->dl_client;
613 struct nfs4_rpc_args *args = task->tk_msg.rpc_argp;
614 u32 minorversion = clp->cl_cb_conn.cb_minorversion;
615 int status = 0;
616
617 args->args_seq.cbs_minorversion = minorversion;
618 if (minorversion) {
619 status = nfsd41_cb_setup_sequence(clp, task);
620 if (status) {
621 if (status != -EAGAIN) {
622 /* terminate rpc task */
623 task->tk_status = status;
624 task->tk_action = NULL;
625 }
626 return;
627 }
628 }
629 rpc_call_start(task);
630}
631
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300632static void nfsd4_cb_done(struct rpc_task *task, void *calldata)
633{
634 struct nfs4_delegation *dp = calldata;
635 struct nfs4_client *clp = dp->dl_client;
636
637 dprintk("%s: minorversion=%d\n", __func__,
638 clp->cl_cb_conn.cb_minorversion);
639
640 if (clp->cl_cb_conn.cb_minorversion) {
641 /* No need for lock, access serialized in nfsd4_cb_prepare */
642 ++clp->cl_cb_seq_nr;
643 clear_bit(0, &clp->cl_cb_slot_busy);
644 rpc_wake_up_next(&clp->cl_cb_waitq);
645 dprintk("%s: freed slot, new seqid=%d\n", __func__,
646 clp->cl_cb_seq_nr);
647
648 /* We're done looking into the sequence information */
649 task->tk_msg.rpc_resp = NULL;
650 }
651}
652
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500653
J. Bruce Fields63e48632009-05-01 22:36:55 -0400654static void nfsd4_cb_recall_done(struct rpc_task *task, void *calldata)
655{
656 struct nfs4_delegation *dp = calldata;
657 struct nfs4_client *clp = dp->dl_client;
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500658 struct rpc_clnt *current_rpc_client = clp->cl_cb_client;
J. Bruce Fields63e48632009-05-01 22:36:55 -0400659
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300660 nfsd4_cb_done(task, calldata);
661
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500662 if (current_rpc_client == NULL) {
663 /* We're shutting down; give up. */
664 /* XXX: err, or is it ok just to fall through
665 * and rpc_restart_call? */
666 return;
667 }
668
J. Bruce Fields63e48632009-05-01 22:36:55 -0400669 switch (task->tk_status) {
670 case -EIO:
671 /* Network partition? */
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500672 atomic_set(&clp->cl_cb_set, 0);
J. Bruce Fields63e48632009-05-01 22:36:55 -0400673 warn_no_callback_path(clp, task->tk_status);
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500674 if (current_rpc_client != task->tk_client) {
675 /* queue a callback on the new connection: */
676 nfsd4_cb_recall(dp);
677 return;
678 }
J. Bruce Fields63e48632009-05-01 22:36:55 -0400679 case -EBADHANDLE:
680 case -NFS4ERR_BAD_STATEID:
681 /* Race: client probably got cb_recall
682 * before open reply granting delegation */
683 break;
684 default:
685 /* success, or error we can't handle */
J. Bruce Fields227f98d2010-02-18 08:27:24 -0800686 return;
J. Bruce Fields63e48632009-05-01 22:36:55 -0400687 }
688 if (dp->dl_retries--) {
689 rpc_delay(task, 2*HZ);
690 task->tk_status = 0;
691 rpc_restart_call(task);
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300692 return;
J. Bruce Fields63e48632009-05-01 22:36:55 -0400693 } else {
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500694 atomic_set(&clp->cl_cb_set, 0);
J. Bruce Fields63e48632009-05-01 22:36:55 -0400695 warn_no_callback_path(clp, task->tk_status);
696 }
697}
698
699static void nfsd4_cb_recall_release(void *calldata)
700{
701 struct nfs4_delegation *dp = calldata;
J. Bruce Fields63e48632009-05-01 22:36:55 -0400702
703 nfs4_put_delegation(dp);
J. Bruce Fields63e48632009-05-01 22:36:55 -0400704}
705
706static const struct rpc_call_ops nfsd4_cb_recall_ops = {
Ricardo Labiaga2a1d1b52009-09-10 12:26:38 +0300707 .rpc_call_prepare = nfsd4_cb_prepare,
J. Bruce Fields63e48632009-05-01 22:36:55 -0400708 .rpc_call_done = nfsd4_cb_recall_done,
709 .rpc_release = nfsd4_cb_recall_release,
710};
711
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500712static struct workqueue_struct *callback_wq;
713
714int nfsd4_create_callback_queue(void)
715{
716 callback_wq = create_singlethread_workqueue("nfsd4_callbacks");
717 if (!callback_wq)
718 return -ENOMEM;
719 return 0;
720}
721
722void nfsd4_destroy_callback_queue(void)
723{
724 destroy_workqueue(callback_wq);
725}
726
Benny Halevyab707e12010-05-12 00:14:06 +0300727/* must be called under the state lock */
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -0500728void nfsd4_set_callback_client(struct nfs4_client *clp, struct rpc_clnt *new)
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500729{
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500730 struct rpc_clnt *old = clp->cl_cb_client;
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500731
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500732 clp->cl_cb_client = new;
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500733 /*
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500734 * After this, any work that saw the old value of cl_cb_client will
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500735 * be gone:
736 */
737 flush_workqueue(callback_wq);
738 /* So we can safely shut it down: */
739 if (old)
740 rpc_shutdown_client(old);
741}
742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743/*
744 * called with dp->dl_count inc'ed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 */
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500746static void _nfsd4_cb_recall(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747{
748 struct nfs4_client *clp = dp->dl_client;
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500749 struct rpc_clnt *clnt = clp->cl_cb_client;
J. Bruce Fields227f98d2010-02-18 08:27:24 -0800750 struct nfs4_rpc_args *args = &dp->dl_recall.cb_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 struct rpc_message msg = {
752 .rpc_proc = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_RECALL],
J. Bruce Fields80fc0152009-09-15 18:07:35 -0400753 .rpc_cred = callback_cred
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 };
J. Bruce Fields227f98d2010-02-18 08:27:24 -0800755 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500757 if (clnt == NULL)
758 return; /* Client is shutting down; give up. */
759
Ricardo Labiaga0421b5c2009-09-10 12:27:04 +0300760 args->args_op = dp;
761 msg.rpc_argp = args;
J. Bruce Fields3aea09d2009-05-01 20:11:12 -0400762 dp->dl_retries = 1;
J. Bruce Fields63e48632009-05-01 22:36:55 -0400763 status = rpc_call_async(clnt, &msg, RPC_TASK_SOFT,
764 &nfsd4_cb_recall_ops, dp);
J. Bruce Fieldsb12a05c2010-03-04 11:32:59 -0500765 if (status)
J. Bruce Fields63e48632009-05-01 22:36:55 -0400766 nfs4_put_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767}
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500768
769void nfsd4_do_callback_rpc(struct work_struct *w)
770{
771 /* XXX: for now, just send off delegation recall. */
772 /* In future, generalize to handle any sort of callback. */
773 struct nfsd4_callback *c = container_of(w, struct nfsd4_callback, cb_work);
774 struct nfs4_delegation *dp = container_of(c, struct nfs4_delegation, dl_recall);
775
776 _nfsd4_cb_recall(dp);
777}
778
779
780void nfsd4_cb_recall(struct nfs4_delegation *dp)
781{
782 queue_work(callback_wq, &dp->dl_recall.cb_work);
783}