callback_xdr.c 27.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11
/*
 * linux/fs/nfs/callback_xdr.c
 *
 * Copyright (C) 2004 Trond Myklebust
 *
 * NFSv4 callback encode/decode procedures
 */
#include <linux/kernel.h>
#include <linux/sunrpc/svc.h>
#include <linux/nfs4.h>
#include <linux/nfs_fs.h>
12 13
#include <linux/ratelimit.h>
#include <linux/printk.h>
14
#include <linux/slab.h>
15
#include <linux/sunrpc/bc_xprt.h>
16
#include "nfs4_fs.h"
L
Linus Torvalds 已提交
17
#include "callback.h"
18
#include "internal.h"
19
#include "nfs4session.h"
L
Linus Torvalds 已提交
20

21 22 23 24 25 26 27 28
#define CB_OP_TAGLEN_MAXSZ		(512)
#define CB_OP_HDR_RES_MAXSZ		(2 * 4) // opcode, status
#define CB_OP_GETATTR_BITMAP_MAXSZ	(4 * 4) // bitmap length, 3 bitmaps
#define CB_OP_GETATTR_RES_MAXSZ		(CB_OP_HDR_RES_MAXSZ + \
					 CB_OP_GETATTR_BITMAP_MAXSZ + \
					 /* change, size, ctime, mtime */\
					 (2 + 2 + 3 + 3) * 4)
#define CB_OP_RECALL_RES_MAXSZ		(CB_OP_HDR_RES_MAXSZ)
L
Linus Torvalds 已提交
29

30
#if defined(CONFIG_NFS_V4_1)
F
Fred Isaman 已提交
31
#define CB_OP_LAYOUTRECALL_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ)
M
Marc Eshel 已提交
32
#define CB_OP_DEVICENOTIFY_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ)
33
#define CB_OP_SEQUENCE_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ + \
34 35
					 NFS4_MAX_SESSIONID_LEN + \
					 (1 + 3) * 4) // seqid, 3 slotids
36
#define CB_OP_RECALLANY_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ)
A
Andy Adamson 已提交
37
#define CB_OP_RECALLSLOT_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ)
38
#define CB_OP_NOTIFY_LOCK_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ)
39 40
#endif /* CONFIG_NFS_V4_1 */

L
Linus Torvalds 已提交
41 42
#define NFSDBG_FACILITY NFSDBG_CALLBACK

43 44 45
/* Internal error code */
#define NFS4ERR_RESOURCE_HDR	11050

46 47
typedef __be32 (*callback_process_op_t)(void *, void *,
					struct cb_process_state *);
48 49
typedef __be32 (*callback_decode_arg_t)(struct svc_rqst *, struct xdr_stream *, void *);
typedef __be32 (*callback_encode_res_t)(struct svc_rqst *, struct xdr_stream *, void *);
L
Linus Torvalds 已提交
50 51 52 53 54 55 56 57 58 59 60


struct callback_op {
	callback_process_op_t process_op;
	callback_decode_arg_t decode_args;
	callback_encode_res_t encode_res;
	long res_maxsize;
};

static struct callback_op callback_ops[];

A
Al Viro 已提交
61
static __be32 nfs4_callback_null(struct svc_rqst *rqstp, void *argp, void *resp)
L
Linus Torvalds 已提交
62 63 64 65
{
	return htonl(NFS4_OK);
}

66
static int nfs4_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
L
Linus Torvalds 已提交
67 68 69 70
{
	return xdr_argsize_check(rqstp, p);
}

71
static int nfs4_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
L
Linus Torvalds 已提交
72 73 74 75
{
	return xdr_ressize_check(rqstp, p);
}

76
static __be32 *read_buf(struct xdr_stream *xdr, size_t nbytes)
L
Linus Torvalds 已提交
77
{
78
	__be32 *p;
L
Linus Torvalds 已提交
79 80 81

	p = xdr_inline_decode(xdr, nbytes);
	if (unlikely(p == NULL))
T
Trond Myklebust 已提交
82
		printk(KERN_WARNING "NFS: NFSv4 callback reply buffer overflowed!\n");
L
Linus Torvalds 已提交
83 84 85
	return p;
}

86 87
static __be32 decode_string(struct xdr_stream *xdr, unsigned int *len,
		const char **str, size_t maxlen)
L
Linus Torvalds 已提交
88
{
89
	ssize_t err;
L
Linus Torvalds 已提交
90

91 92 93 94
	err = xdr_stream_decode_opaque_inline(xdr, (void **)str, maxlen);
	if (err < 0)
		return cpu_to_be32(NFS4ERR_RESOURCE);
	*len = err;
L
Linus Torvalds 已提交
95 96 97
	return 0;
}

98
static __be32 decode_fh(struct xdr_stream *xdr, struct nfs_fh *fh)
L
Linus Torvalds 已提交
99
{
100
	__be32 *p;
L
Linus Torvalds 已提交
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	fh->size = ntohl(*p);
	if (fh->size > NFS4_FHSIZE)
		return htonl(NFS4ERR_BADHANDLE);
	p = read_buf(xdr, fh->size);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	memcpy(&fh->data[0], p, fh->size);
	memset(&fh->data[fh->size], 0, sizeof(fh->data) - fh->size);
	return 0;
}

116
static __be32 decode_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
L
Linus Torvalds 已提交
117
{
118
	__be32 *p;
L
Linus Torvalds 已提交
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
	unsigned int attrlen;

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	attrlen = ntohl(*p);
	p = read_buf(xdr, attrlen << 2);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	if (likely(attrlen > 0))
		bitmap[0] = ntohl(*p++);
	if (attrlen > 1)
		bitmap[1] = ntohl(*p);
	return 0;
}

135
static __be32 decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
L
Linus Torvalds 已提交
136
{
137
	__be32 *p;
L
Linus Torvalds 已提交
138

139
	p = read_buf(xdr, NFS4_STATEID_SIZE);
L
Linus Torvalds 已提交
140 141
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
142
	memcpy(stateid->data, p, NFS4_STATEID_SIZE);
L
Linus Torvalds 已提交
143 144 145
	return 0;
}

146 147 148 149 150 151
static __be32 decode_delegation_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
{
	stateid->type = NFS4_DELEGATION_STATEID_TYPE;
	return decode_stateid(xdr, stateid);
}

152
static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound_hdr_arg *hdr)
L
Linus Torvalds 已提交
153
{
154
	__be32 *p;
155
	__be32 status;
L
Linus Torvalds 已提交
156

157
	status = decode_string(xdr, &hdr->taglen, &hdr->tag, CB_OP_TAGLEN_MAXSZ);
L
Linus Torvalds 已提交
158 159 160 161 162
	if (unlikely(status != 0))
		return status;
	p = read_buf(xdr, 12);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
163
	hdr->minorversion = ntohl(*p++);
164 165
	/* Check for minor version support */
	if (hdr->minorversion <= NFS4_MAX_MINOR_VERSION) {
166
		hdr->cb_ident = ntohl(*p++); /* ignored by v4.1 and v4.2 */
167
	} else {
168
		pr_warn_ratelimited("NFS: %s: NFSv4 server callback with "
169 170
			"illegal minor version %u!\n",
			__func__, hdr->minorversion);
L
Linus Torvalds 已提交
171 172 173
		return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
	}
	hdr->nops = ntohl(*p);
174 175
	dprintk("%s: minorversion %d nops %d\n", __func__,
		hdr->minorversion, hdr->nops);
L
Linus Torvalds 已提交
176 177 178
	return 0;
}

179
static __be32 decode_op_hdr(struct xdr_stream *xdr, unsigned int *op)
L
Linus Torvalds 已提交
180
{
181
	__be32 *p;
L
Linus Torvalds 已提交
182 183
	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
184
		return htonl(NFS4ERR_RESOURCE_HDR);
L
Linus Torvalds 已提交
185 186 187 188
	*op = ntohl(*p);
	return 0;
}

189
static __be32 decode_getattr_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_getattrargs *args)
L
Linus Torvalds 已提交
190
{
191
	__be32 status;
L
Linus Torvalds 已提交
192 193 194 195 196 197

	status = decode_fh(xdr, &args->fh);
	if (unlikely(status != 0))
		goto out;
	status = decode_bitmap(xdr, args->bitmap);
out:
198
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
199 200 201
	return status;
}

202
static __be32 decode_recall_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_recallargs *args)
L
Linus Torvalds 已提交
203
{
204
	__be32 *p;
205
	__be32 status;
L
Linus Torvalds 已提交
206

207
	status = decode_delegation_stateid(xdr, &args->stateid);
L
Linus Torvalds 已提交
208 209 210 211 212 213 214 215 216 217
	if (unlikely(status != 0))
		goto out;
	p = read_buf(xdr, 4);
	if (unlikely(p == NULL)) {
		status = htonl(NFS4ERR_RESOURCE);
		goto out;
	}
	args->truncate = ntohl(*p);
	status = decode_fh(xdr, &args->fh);
out:
218
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
219
	return status;
L
Linus Torvalds 已提交
220 221
}

222
#if defined(CONFIG_NFS_V4_1)
223 224 225 226 227
static __be32 decode_layout_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
{
	stateid->type = NFS4_LAYOUT_STATEID_TYPE;
	return decode_stateid(xdr, stateid);
}
228

F
Fred Isaman 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
static __be32 decode_layoutrecall_args(struct svc_rqst *rqstp,
				       struct xdr_stream *xdr,
				       struct cb_layoutrecallargs *args)
{
	__be32 *p;
	__be32 status = 0;
	uint32_t iomode;

	p = read_buf(xdr, 4 * sizeof(uint32_t));
	if (unlikely(p == NULL)) {
		status = htonl(NFS4ERR_BADXDR);
		goto out;
	}

	args->cbl_layout_type = ntohl(*p++);
	/* Depite the spec's xdr, iomode really belongs in the FILE switch,
L
Lucas De Marchi 已提交
245
	 * as it is unusable and ignored with the other types.
F
Fred Isaman 已提交
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
	 */
	iomode = ntohl(*p++);
	args->cbl_layoutchanged = ntohl(*p++);
	args->cbl_recall_type = ntohl(*p++);

	if (args->cbl_recall_type == RETURN_FILE) {
		args->cbl_range.iomode = iomode;
		status = decode_fh(xdr, &args->cbl_fh);
		if (unlikely(status != 0))
			goto out;

		p = read_buf(xdr, 2 * sizeof(uint64_t));
		if (unlikely(p == NULL)) {
			status = htonl(NFS4ERR_BADXDR);
			goto out;
		}
		p = xdr_decode_hyper(p, &args->cbl_range.offset);
		p = xdr_decode_hyper(p, &args->cbl_range.length);
264
		status = decode_layout_stateid(xdr, &args->cbl_stateid);
F
Fred Isaman 已提交
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
		if (unlikely(status != 0))
			goto out;
	} else if (args->cbl_recall_type == RETURN_FSID) {
		p = read_buf(xdr, 2 * sizeof(uint64_t));
		if (unlikely(p == NULL)) {
			status = htonl(NFS4ERR_BADXDR);
			goto out;
		}
		p = xdr_decode_hyper(p, &args->cbl_fsid.major);
		p = xdr_decode_hyper(p, &args->cbl_fsid.minor);
	} else if (args->cbl_recall_type != RETURN_ALL) {
		status = htonl(NFS4ERR_BADXDR);
		goto out;
	}
	dprintk("%s: ltype 0x%x iomode %d changed %d recall_type %d\n",
		__func__,
		args->cbl_layout_type, iomode,
		args->cbl_layoutchanged, args->cbl_recall_type);
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}

M
Marc Eshel 已提交
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
static
__be32 decode_devicenotify_args(struct svc_rqst *rqstp,
				struct xdr_stream *xdr,
				struct cb_devicenotifyargs *args)
{
	__be32 *p;
	__be32 status = 0;
	u32 tmp;
	int n, i;
	args->ndevs = 0;

	/* Num of device notifications */
	p = read_buf(xdr, sizeof(uint32_t));
	if (unlikely(p == NULL)) {
		status = htonl(NFS4ERR_BADXDR);
		goto out;
	}
	n = ntohl(*p++);
	if (n <= 0)
		goto out;
308 309 310 311
	if (n > ULONG_MAX / sizeof(*args->devs)) {
		status = htonl(NFS4ERR_BADXDR);
		goto out;
	}
M
Marc Eshel 已提交
312

313
	args->devs = kmalloc_array(n, sizeof(*args->devs), GFP_KERNEL);
M
Marc Eshel 已提交
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
	if (!args->devs) {
		status = htonl(NFS4ERR_DELAY);
		goto out;
	}

	/* Decode each dev notification */
	for (i = 0; i < n; i++) {
		struct cb_devicenotifyitem *dev = &args->devs[i];

		p = read_buf(xdr, (4 * sizeof(uint32_t)) + NFS4_DEVICEID4_SIZE);
		if (unlikely(p == NULL)) {
			status = htonl(NFS4ERR_BADXDR);
			goto err;
		}

		tmp = ntohl(*p++);	/* bitmap size */
		if (tmp != 1) {
			status = htonl(NFS4ERR_INVAL);
			goto err;
		}
		dev->cbd_notify_type = ntohl(*p++);
		if (dev->cbd_notify_type != NOTIFY_DEVICEID4_CHANGE &&
		    dev->cbd_notify_type != NOTIFY_DEVICEID4_DELETE) {
			status = htonl(NFS4ERR_INVAL);
			goto err;
		}

		tmp = ntohl(*p++);	/* opaque size */
		if (((dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE) &&
		     (tmp != NFS4_DEVICEID4_SIZE + 8)) ||
		    ((dev->cbd_notify_type == NOTIFY_DEVICEID4_DELETE) &&
		     (tmp != NFS4_DEVICEID4_SIZE + 4))) {
			status = htonl(NFS4ERR_INVAL);
			goto err;
		}
		dev->cbd_layout_type = ntohl(*p++);
		memcpy(dev->cbd_dev_id.data, p, NFS4_DEVICEID4_SIZE);
		p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);

		if (dev->cbd_layout_type == NOTIFY_DEVICEID4_CHANGE) {
			p = read_buf(xdr, sizeof(uint32_t));
			if (unlikely(p == NULL)) {
				status = htonl(NFS4ERR_BADXDR);
				goto err;
			}
			dev->cbd_immediate = ntohl(*p++);
		} else {
			dev->cbd_immediate = 0;
		}

		args->ndevs++;

		dprintk("%s: type %d layout 0x%x immediate %d\n",
			__func__, dev->cbd_notify_type, dev->cbd_layout_type,
			dev->cbd_immediate);
	}
out:
	dprintk("%s: status %d ndevs %d\n",
		__func__, ntohl(status), args->ndevs);
	return status;
err:
	kfree(args->devs);
	goto out;
}

379
static __be32 decode_sessionid(struct xdr_stream *xdr,
380 381
				 struct nfs4_sessionid *sid)
{
382
	__be32 *p;
383

384
	p = read_buf(xdr, NFS4_MAX_SESSIONID_LEN);
385
	if (unlikely(p == NULL))
386
		return htonl(NFS4ERR_RESOURCE);
387

388
	memcpy(sid->data, p, NFS4_MAX_SESSIONID_LEN);
389 390 391
	return 0;
}

392
static __be32 decode_rc_list(struct xdr_stream *xdr,
393 394
			       struct referring_call_list *rc_list)
{
395
	__be32 *p;
396
	int i;
397
	__be32 status;
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413

	status = decode_sessionid(xdr, &rc_list->rcl_sessionid);
	if (status)
		goto out;

	status = htonl(NFS4ERR_RESOURCE);
	p = read_buf(xdr, sizeof(uint32_t));
	if (unlikely(p == NULL))
		goto out;

	rc_list->rcl_nrefcalls = ntohl(*p++);
	if (rc_list->rcl_nrefcalls) {
		p = read_buf(xdr,
			     rc_list->rcl_nrefcalls * 2 * sizeof(uint32_t));
		if (unlikely(p == NULL))
			goto out;
414
		rc_list->rcl_refcalls = kmalloc_array(rc_list->rcl_nrefcalls,
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
						sizeof(*rc_list->rcl_refcalls),
						GFP_KERNEL);
		if (unlikely(rc_list->rcl_refcalls == NULL))
			goto out;
		for (i = 0; i < rc_list->rcl_nrefcalls; i++) {
			rc_list->rcl_refcalls[i].rc_sequenceid = ntohl(*p++);
			rc_list->rcl_refcalls[i].rc_slotid = ntohl(*p++);
		}
	}
	status = 0;

out:
	return status;
}

430
static __be32 decode_cb_sequence_args(struct svc_rqst *rqstp,
431 432 433
					struct xdr_stream *xdr,
					struct cb_sequenceargs *args)
{
434
	__be32 *p;
435
	int i;
436
	__be32 status;
437 438 439 440 441 442 443 444 445 446

	status = decode_sessionid(xdr, &args->csa_sessionid);
	if (status)
		goto out;

	status = htonl(NFS4ERR_RESOURCE);
	p = read_buf(xdr, 5 * sizeof(uint32_t));
	if (unlikely(p == NULL))
		goto out;

447
	args->csa_addr = svc_addr(rqstp);
448 449 450 451 452 453 454
	args->csa_sequenceid = ntohl(*p++);
	args->csa_slotid = ntohl(*p++);
	args->csa_highestslotid = ntohl(*p++);
	args->csa_cachethis = ntohl(*p++);
	args->csa_nrclists = ntohl(*p++);
	args->csa_rclists = NULL;
	if (args->csa_nrclists) {
455 456 457
		args->csa_rclists = kmalloc_array(args->csa_nrclists,
						  sizeof(*args->csa_rclists),
						  GFP_KERNEL);
458 459 460 461 462
		if (unlikely(args->csa_rclists == NULL))
			goto out;

		for (i = 0; i < args->csa_nrclists; i++) {
			status = decode_rc_list(xdr, &args->csa_rclists[i]);
463 464
			if (status) {
				args->csa_nrclists = i;
465
				goto out_free;
466
			}
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
		}
	}
	status = 0;

	dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u slotid %u "
		"highestslotid %u cachethis %d nrclists %u\n",
		__func__,
		((u32 *)&args->csa_sessionid)[0],
		((u32 *)&args->csa_sessionid)[1],
		((u32 *)&args->csa_sessionid)[2],
		((u32 *)&args->csa_sessionid)[3],
		args->csa_sequenceid, args->csa_slotid,
		args->csa_highestslotid, args->csa_cachethis,
		args->csa_nrclists);
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;

out_free:
	for (i = 0; i < args->csa_nrclists; i++)
		kfree(args->csa_rclists[i].rcl_refcalls);
	kfree(args->csa_rclists);
	goto out;
}

492
static __be32 decode_recallany_args(struct svc_rqst *rqstp,
493 494 495
				      struct xdr_stream *xdr,
				      struct cb_recallanyargs *args)
{
P
Peng Tao 已提交
496 497
	uint32_t bitmap[2];
	__be32 *p, status;
498 499 500 501 502

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);
	args->craa_objs_to_keep = ntohl(*p++);
P
Peng Tao 已提交
503 504 505 506
	status = decode_bitmap(xdr, bitmap);
	if (unlikely(status))
		return status;
	args->craa_type_mask = bitmap[0];
507 508 509 510

	return 0;
}

511
static __be32 decode_recallslot_args(struct svc_rqst *rqstp,
A
Andy Adamson 已提交
512 513 514 515 516 517 518 519
					struct xdr_stream *xdr,
					struct cb_recallslotargs *args)
{
	__be32 *p;

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);
520
	args->crsa_target_highest_slotid = ntohl(*p++);
A
Andy Adamson 已提交
521 522 523
	return 0;
}

524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
static __be32 decode_lockowner(struct xdr_stream *xdr, struct cb_notify_lock_args *args)
{
	__be32		*p;
	unsigned int	len;

	p = read_buf(xdr, 12);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);

	p = xdr_decode_hyper(p, &args->cbnl_owner.clientid);
	len = be32_to_cpu(*p);

	p = read_buf(xdr, len);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);

	/* Only try to decode if the length is right */
	if (len == 20) {
		p += 2;	/* skip "lock id:" */
		args->cbnl_owner.s_dev = be32_to_cpu(*p++);
		xdr_decode_hyper(p, &args->cbnl_owner.id);
		args->cbnl_valid = true;
	} else {
		args->cbnl_owner.s_dev = 0;
		args->cbnl_owner.id = 0;
		args->cbnl_valid = false;
	}
	return 0;
}

static __be32 decode_notify_lock_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_notify_lock_args *args)
{
	__be32 status;

	status = decode_fh(xdr, &args->cbnl_fh);
	if (unlikely(status != 0))
		goto out;
	status = decode_lockowner(xdr, args);
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}

567 568
#endif /* CONFIG_NFS_V4_1 */

569
static __be32 encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
L
Linus Torvalds 已提交
570
{
571 572
	if (unlikely(xdr_stream_encode_opaque(xdr, str, len) < 0))
		return cpu_to_be32(NFS4ERR_RESOURCE);
L
Linus Torvalds 已提交
573 574 575 576 577
	return 0;
}

#define CB_SUPPORTED_ATTR0 (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE)
#define CB_SUPPORTED_ATTR1 (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY)
578
static __be32 encode_attr_bitmap(struct xdr_stream *xdr, const uint32_t *bitmap, __be32 **savep)
L
Linus Torvalds 已提交
579
{
580 581
	__be32 bm[2];
	__be32 *p;
L
Linus Torvalds 已提交
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607

	bm[0] = htonl(bitmap[0] & CB_SUPPORTED_ATTR0);
	bm[1] = htonl(bitmap[1] & CB_SUPPORTED_ATTR1);
	if (bm[1] != 0) {
		p = xdr_reserve_space(xdr, 16);
		if (unlikely(p == NULL))
			return htonl(NFS4ERR_RESOURCE);
		*p++ = htonl(2);
		*p++ = bm[0];
		*p++ = bm[1];
	} else if (bm[0] != 0) {
		p = xdr_reserve_space(xdr, 12);
		if (unlikely(p == NULL))
			return htonl(NFS4ERR_RESOURCE);
		*p++ = htonl(1);
		*p++ = bm[0];
	} else {
		p = xdr_reserve_space(xdr, 8);
		if (unlikely(p == NULL))
			return htonl(NFS4ERR_RESOURCE);
		*p++ = htonl(0);
	}
	*savep = p;
	return 0;
}

608
static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t change)
L
Linus Torvalds 已提交
609
{
610
	__be32 *p;
L
Linus Torvalds 已提交
611 612 613 614

	if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
		return 0;
	p = xdr_reserve_space(xdr, 8);
H
Harvey Harrison 已提交
615
	if (unlikely(!p))
L
Linus Torvalds 已提交
616 617 618 619 620
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, change);
	return 0;
}

621
static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t size)
L
Linus Torvalds 已提交
622
{
623
	__be32 *p;
L
Linus Torvalds 已提交
624 625 626 627

	if (!(bitmap[0] & FATTR4_WORD0_SIZE))
		return 0;
	p = xdr_reserve_space(xdr, 8);
H
Harvey Harrison 已提交
628
	if (unlikely(!p))
L
Linus Torvalds 已提交
629 630 631 632 633
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, size);
	return 0;
}

634
static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec *time)
L
Linus Torvalds 已提交
635
{
636
	__be32 *p;
L
Linus Torvalds 已提交
637 638

	p = xdr_reserve_space(xdr, 12);
H
Harvey Harrison 已提交
639
	if (unlikely(!p))
L
Linus Torvalds 已提交
640 641 642 643 644 645
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, time->tv_sec);
	*p = htonl(time->tv_nsec);
	return 0;
}

646
static __be32 encode_attr_ctime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec *time)
L
Linus Torvalds 已提交
647 648 649 650 651 652
{
	if (!(bitmap[1] & FATTR4_WORD1_TIME_METADATA))
		return 0;
	return encode_attr_time(xdr,time);
}

653
static __be32 encode_attr_mtime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec *time)
L
Linus Torvalds 已提交
654 655 656 657 658 659
{
	if (!(bitmap[1] & FATTR4_WORD1_TIME_MODIFY))
		return 0;
	return encode_attr_time(xdr,time);
}

660
static __be32 encode_compound_hdr_res(struct xdr_stream *xdr, struct cb_compound_hdr_res *hdr)
L
Linus Torvalds 已提交
661
{
662
	__be32 status;
L
Linus Torvalds 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675

	hdr->status = xdr_reserve_space(xdr, 4);
	if (unlikely(hdr->status == NULL))
		return htonl(NFS4ERR_RESOURCE);
	status = encode_string(xdr, hdr->taglen, hdr->tag);
	if (unlikely(status != 0))
		return status;
	hdr->nops = xdr_reserve_space(xdr, 4);
	if (unlikely(hdr->nops == NULL))
		return htonl(NFS4ERR_RESOURCE);
	return 0;
}

676
static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res)
L
Linus Torvalds 已提交
677
{
678
	__be32 *p;
L
Linus Torvalds 已提交
679 680 681
	
	p = xdr_reserve_space(xdr, 8);
	if (unlikely(p == NULL))
682
		return htonl(NFS4ERR_RESOURCE_HDR);
L
Linus Torvalds 已提交
683 684 685 686 687
	*p++ = htonl(op);
	*p = res;
	return 0;
}

688
static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr, const struct cb_getattrres *res)
L
Linus Torvalds 已提交
689
{
690
	__be32 *savep = NULL;
691
	__be32 status = res->status;
L
Linus Torvalds 已提交
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
	
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_bitmap(xdr, res->bitmap, &savep);
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_change(xdr, res->bitmap, res->change_attr);
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_size(xdr, res->bitmap, res->size);
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_ctime(xdr, res->bitmap, &res->ctime);
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_mtime(xdr, res->bitmap, &res->mtime);
	*savep = htonl((unsigned int)((char *)xdr->p - (char *)(savep+1)));
out:
710
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
711 712 713
	return status;
}

714 715
#if defined(CONFIG_NFS_V4_1)

716
static __be32 encode_sessionid(struct xdr_stream *xdr,
717 718
				 const struct nfs4_sessionid *sid)
{
719
	__be32 *p;
720

721
	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN);
722 723 724
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);

725
	memcpy(p, sid, NFS4_MAX_SESSIONID_LEN);
726 727 728
	return 0;
}

729
static __be32 encode_cb_sequence_res(struct svc_rqst *rqstp,
730 731 732
				       struct xdr_stream *xdr,
				       const struct cb_sequenceres *res)
{
733
	__be32 *p;
734
	__be32 status = res->csr_status;
735 736 737 738

	if (unlikely(status != 0))
		goto out;

739 740 741
	status = encode_sessionid(xdr, &res->csr_sessionid);
	if (status)
		goto out;
742 743 744 745 746 747 748 749 750 751 752 753 754 755

	p = xdr_reserve_space(xdr, 4 * sizeof(uint32_t));
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);

	*p++ = htonl(res->csr_sequenceid);
	*p++ = htonl(res->csr_slotid);
	*p++ = htonl(res->csr_highestslotid);
	*p++ = htonl(res->csr_target_highestslotid);
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}

756 757 758
static __be32
preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
{
759 760 761 762 763 764 765 766
	if (op_nr == OP_CB_SEQUENCE) {
		if (nop != 0)
			return htonl(NFS4ERR_SEQUENCE_POS);
	} else {
		if (nop == 0)
			return htonl(NFS4ERR_OP_NOT_IN_SESSION);
	}

767 768 769
	switch (op_nr) {
	case OP_CB_GETATTR:
	case OP_CB_RECALL:
770
	case OP_CB_SEQUENCE:
771
	case OP_CB_RECALL_ANY:
A
Andy Adamson 已提交
772
	case OP_CB_RECALL_SLOT:
F
Fred Isaman 已提交
773
	case OP_CB_LAYOUTRECALL:
M
Marc Eshel 已提交
774
	case OP_CB_NOTIFY_DEVICEID:
775
	case OP_CB_NOTIFY_LOCK:
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
		*op = &callback_ops[op_nr];
		break;

	case OP_CB_NOTIFY:
	case OP_CB_PUSH_DELEG:
	case OP_CB_RECALLABLE_OBJ_AVAIL:
	case OP_CB_WANTS_CANCELLED:
		return htonl(NFS4ERR_NOTSUPP);

	default:
		return htonl(NFS4ERR_OP_ILLEGAL);
	}

	return htonl(NFS_OK);
}

792 793
static void nfs4_callback_free_slot(struct nfs4_session *session,
		struct nfs4_slot *slot)
794 795 796 797 798 799 800 801
{
	struct nfs4_slot_table *tbl = &session->bc_slot_table;

	spin_lock(&tbl->slot_tbl_lock);
	/*
	 * Let the state manager know callback processing done.
	 * A single slot, so highest used slotid is either 0 or -1
	 */
802
	nfs4_free_slot(tbl, slot);
803
	nfs4_slot_tbl_drain_complete(tbl);
804 805 806
	spin_unlock(&tbl->slot_tbl_lock);
}

807
static void nfs4_cb_free_slot(struct cb_process_state *cps)
808
{
809 810 811 812
	if (cps->slot) {
		nfs4_callback_free_slot(cps->clp->cl_session, cps->slot);
		cps->slot = NULL;
	}
813 814
}

815 816 817 818 819 820 821 822
#else /* CONFIG_NFS_V4_1 */

static __be32
preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
{
	return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
}

823
static void nfs4_cb_free_slot(struct cb_process_state *cps)
824 825
{
}
826 827
#endif /* CONFIG_NFS_V4_1 */

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
#ifdef CONFIG_NFS_V4_2
static __be32
preprocess_nfs42_op(int nop, unsigned int op_nr, struct callback_op **op)
{
	__be32 status = preprocess_nfs41_op(nop, op_nr, op);
	if (status != htonl(NFS4ERR_OP_ILLEGAL))
		return status;

	if (op_nr == OP_CB_OFFLOAD)
		return htonl(NFS4ERR_NOTSUPP);
	return htonl(NFS4ERR_OP_ILLEGAL);
}
#else /* CONFIG_NFS_V4_2 */
static __be32
preprocess_nfs42_op(int nop, unsigned int op_nr, struct callback_op **op)
{
	return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
}
#endif /* CONFIG_NFS_V4_2 */

848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
static __be32
preprocess_nfs4_op(unsigned int op_nr, struct callback_op **op)
{
	switch (op_nr) {
	case OP_CB_GETATTR:
	case OP_CB_RECALL:
		*op = &callback_ops[op_nr];
		break;
	default:
		return htonl(NFS4ERR_OP_ILLEGAL);
	}

	return htonl(NFS_OK);
}

863
static __be32 process_op(int nop, struct svc_rqst *rqstp,
L
Linus Torvalds 已提交
864
		struct xdr_stream *xdr_in, void *argp,
865 866
		struct xdr_stream *xdr_out, void *resp,
		struct cb_process_state *cps)
L
Linus Torvalds 已提交
867
{
868
	struct callback_op *op = &callback_ops[0];
869
	unsigned int op_nr;
870
	__be32 status;
L
Linus Torvalds 已提交
871
	long maxlen;
872
	__be32 res;
L
Linus Torvalds 已提交
873

874
	dprintk("%s: start\n", __func__);
L
Linus Torvalds 已提交
875
	status = decode_op_hdr(xdr_in, &op_nr);
876 877
	if (unlikely(status))
		return status;
L
Linus Torvalds 已提交
878

879
	dprintk("%s: minorversion=%d nop=%d op_nr=%u\n",
880
		__func__, cps->minorversion, nop, op_nr);
881

882 883 884 885 886 887 888 889 890 891 892 893 894
	switch (cps->minorversion) {
	case 0:
		status = preprocess_nfs4_op(op_nr, &op);
		break;
	case 1:
		status = preprocess_nfs41_op(nop, op_nr, &op);
		break;
	case 2:
		status = preprocess_nfs42_op(nop, op_nr, &op);
		break;
	default:
		status = htonl(NFS4ERR_MINOR_VERS_MISMATCH);
	}
895 896 897

	if (status == htonl(NFS4ERR_OP_ILLEGAL))
		op_nr = OP_CB_ILLEGAL;
898 899
	if (status)
		goto encode_hdr;
900

901 902
	if (cps->drc_status) {
		status = cps->drc_status;
903 904 905
		goto encode_hdr;
	}

L
Linus Torvalds 已提交
906 907
	maxlen = xdr_out->end - xdr_out->p;
	if (maxlen > 0 && maxlen < PAGE_SIZE) {
908 909
		status = op->decode_args(rqstp, xdr_in, argp);
		if (likely(status == 0))
910
			status = op->process_op(argp, resp, cps);
L
Linus Torvalds 已提交
911 912 913
	} else
		status = htonl(NFS4ERR_RESOURCE);

914
encode_hdr:
L
Linus Torvalds 已提交
915
	res = encode_op_hdr(xdr_out, op_nr, status);
916 917
	if (unlikely(res))
		return res;
L
Linus Torvalds 已提交
918 919
	if (op->encode_res != NULL && status == 0)
		status = op->encode_res(rqstp, xdr_out, resp);
920
	dprintk("%s: done, status = %d\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
921 922 923 924 925 926
	return status;
}

/*
 * Decode, process and encode a COMPOUND
 */
A
Al Viro 已提交
927
static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
L
Linus Torvalds 已提交
928
{
929 930
	struct cb_compound_hdr_arg hdr_arg = { 0 };
	struct cb_compound_hdr_res hdr_res = { NULL };
L
Linus Torvalds 已提交
931
	struct xdr_stream xdr_in, xdr_out;
932 933 934 935
	__be32 *p, status;
	struct cb_process_state cps = {
		.drc_status = 0,
		.clp = NULL,
936
		.net = SVC_NET(rqstp),
937
	};
938
	unsigned int nops = 0;
L
Linus Torvalds 已提交
939

940
	dprintk("%s: start\n", __func__);
L
Linus Torvalds 已提交
941

T
Trond Myklebust 已提交
942
	xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
L
Linus Torvalds 已提交
943

944
	p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
L
Linus Torvalds 已提交
945 946
	xdr_init_encode(&xdr_out, &rqstp->rq_res, p);

947
	status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
948
	if (status == htonl(NFS4ERR_RESOURCE))
949 950
		return rpc_garbage_args;

951
	if (hdr_arg.minorversion == 0) {
952
		cps.clp = nfs4_find_client_ident(SVC_NET(rqstp), hdr_arg.cb_ident);
953
		if (!cps.clp || !check_gss_callback_principal(cps.clp, rqstp))
954
			goto out_invalidcred;
955
	}
956

957
	cps.minorversion = hdr_arg.minorversion;
L
Linus Torvalds 已提交
958 959
	hdr_res.taglen = hdr_arg.taglen;
	hdr_res.tag = hdr_arg.tag;
960 961
	if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
		return rpc_system_err;
L
Linus Torvalds 已提交
962

963
	while (status == 0 && nops != hdr_arg.nops) {
964 965
		status = process_op(nops, rqstp, &xdr_in,
				    argp, &xdr_out, resp, &cps);
L
Linus Torvalds 已提交
966 967
		nops++;
	}
968

969 970 971 972 973 974 975
	/* Buffer overflow in decode_ops_hdr or encode_ops_hdr. Return
	* resource error in cb_compound status without returning op */
	if (unlikely(status == htonl(NFS4ERR_RESOURCE_HDR))) {
		status = htonl(NFS4ERR_RESOURCE);
		nops--;
	}

L
Linus Torvalds 已提交
976 977
	*hdr_res.status = status;
	*hdr_res.nops = htonl(nops);
978
	nfs4_cb_free_slot(&cps);
979
	nfs_put_client(cps.clp);
980
	dprintk("%s: done, status = %u\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
981
	return rpc_success;
982 983 984 985

out_invalidcred:
	pr_warn_ratelimited("NFS: NFSv4 callback contains invalid cred\n");
	return rpc_autherr_badcred;
L
Linus Torvalds 已提交
986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
}

/*
 * Define NFS4 callback COMPOUND ops.
 */
static struct callback_op callback_ops[] = {
	[0] = {
		.res_maxsize = CB_OP_HDR_RES_MAXSZ,
	},
	[OP_CB_GETATTR] = {
		.process_op = (callback_process_op_t)nfs4_callback_getattr,
		.decode_args = (callback_decode_arg_t)decode_getattr_args,
		.encode_res = (callback_encode_res_t)encode_getattr_res,
		.res_maxsize = CB_OP_GETATTR_RES_MAXSZ,
	},
	[OP_CB_RECALL] = {
		.process_op = (callback_process_op_t)nfs4_callback_recall,
		.decode_args = (callback_decode_arg_t)decode_recall_args,
		.res_maxsize = CB_OP_RECALL_RES_MAXSZ,
1005 1006
	},
#if defined(CONFIG_NFS_V4_1)
F
Fred Isaman 已提交
1007 1008 1009 1010 1011 1012
	[OP_CB_LAYOUTRECALL] = {
		.process_op = (callback_process_op_t)nfs4_callback_layoutrecall,
		.decode_args =
			(callback_decode_arg_t)decode_layoutrecall_args,
		.res_maxsize = CB_OP_LAYOUTRECALL_RES_MAXSZ,
	},
M
Marc Eshel 已提交
1013 1014 1015 1016 1017 1018
	[OP_CB_NOTIFY_DEVICEID] = {
		.process_op = (callback_process_op_t)nfs4_callback_devicenotify,
		.decode_args =
			(callback_decode_arg_t)decode_devicenotify_args,
		.res_maxsize = CB_OP_DEVICENOTIFY_RES_MAXSZ,
	},
1019 1020 1021 1022 1023 1024
	[OP_CB_SEQUENCE] = {
		.process_op = (callback_process_op_t)nfs4_callback_sequence,
		.decode_args = (callback_decode_arg_t)decode_cb_sequence_args,
		.encode_res = (callback_encode_res_t)encode_cb_sequence_res,
		.res_maxsize = CB_OP_SEQUENCE_RES_MAXSZ,
	},
1025 1026 1027 1028 1029
	[OP_CB_RECALL_ANY] = {
		.process_op = (callback_process_op_t)nfs4_callback_recallany,
		.decode_args = (callback_decode_arg_t)decode_recallany_args,
		.res_maxsize = CB_OP_RECALLANY_RES_MAXSZ,
	},
A
Andy Adamson 已提交
1030 1031 1032 1033 1034
	[OP_CB_RECALL_SLOT] = {
		.process_op = (callback_process_op_t)nfs4_callback_recallslot,
		.decode_args = (callback_decode_arg_t)decode_recallslot_args,
		.res_maxsize = CB_OP_RECALLSLOT_RES_MAXSZ,
	},
1035 1036 1037 1038 1039
	[OP_CB_NOTIFY_LOCK] = {
		.process_op = (callback_process_op_t)nfs4_callback_notify_lock,
		.decode_args = (callback_decode_arg_t)decode_notify_lock_args,
		.res_maxsize = CB_OP_NOTIFY_LOCK_RES_MAXSZ,
	},
1040
#endif /* CONFIG_NFS_V4_1 */
L
Linus Torvalds 已提交
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
};

/*
 * Define NFS4 callback procedures
 */
static struct svc_procedure nfs4_callback_procedures1[] = {
	[CB_NULL] = {
		.pc_func = nfs4_callback_null,
		.pc_decode = (kxdrproc_t)nfs4_decode_void,
		.pc_encode = (kxdrproc_t)nfs4_encode_void,
		.pc_xdrressize = 1,
	},
	[CB_COMPOUND] = {
		.pc_func = nfs4_callback_compound,
		.pc_encode = (kxdrproc_t)nfs4_encode_void,
		.pc_argsize = 256,
		.pc_ressize = 256,
		.pc_xdrressize = NFS4_CALLBACK_BUFSIZE,
	}
};

struct svc_version nfs4_callback_version1 = {
	.vs_vers = 1,
	.vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
	.vs_proc = nfs4_callback_procedures1,
	.vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
	.vs_dispatch = NULL,
1068
	.vs_hidden = true,
1069
	.vs_need_cong_ctrl = true,
L
Linus Torvalds 已提交
1070 1071
};

1072 1073 1074 1075 1076 1077
struct svc_version nfs4_callback_version4 = {
	.vs_vers = 4,
	.vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
	.vs_proc = nfs4_callback_procedures1,
	.vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
	.vs_dispatch = NULL,
1078
	.vs_hidden = true,
1079
	.vs_need_cong_ctrl = true,
1080
};