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

	status = decode_fh(xdr, &args->fh);
	if (unlikely(status != 0))
195 196
		return status;
	return decode_bitmap(xdr, args->bitmap);
L
Linus Torvalds 已提交
197 198
}

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

204
	status = decode_delegation_stateid(xdr, &args->stateid);
L
Linus Torvalds 已提交
205 206 207 208 209 210 211 212 213 214
	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:
215
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
216
	return status;
L
Linus Torvalds 已提交
217 218
}

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

F
Fred Isaman 已提交
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
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 已提交
242
	 * as it is unusable and ignored with the other types.
F
Fred Isaman 已提交
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
	 */
	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);
261
		status = decode_layout_stateid(xdr, &args->cbl_stateid);
F
Fred Isaman 已提交
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
		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 已提交
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
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;
305 306 307 308
	if (n > ULONG_MAX / sizeof(*args->devs)) {
		status = htonl(NFS4ERR_BADXDR);
		goto out;
	}
M
Marc Eshel 已提交
309

310
	args->devs = kmalloc_array(n, sizeof(*args->devs), GFP_KERNEL);
M
Marc Eshel 已提交
311 312 313 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
	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;
}

376
static __be32 decode_sessionid(struct xdr_stream *xdr,
377 378
				 struct nfs4_sessionid *sid)
{
379
	__be32 *p;
380

381
	p = read_buf(xdr, NFS4_MAX_SESSIONID_LEN);
382
	if (unlikely(p == NULL))
383
		return htonl(NFS4ERR_RESOURCE);
384

385
	memcpy(sid->data, p, NFS4_MAX_SESSIONID_LEN);
386 387 388
	return 0;
}

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

	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;
411
		rc_list->rcl_refcalls = kmalloc_array(rc_list->rcl_nrefcalls,
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
						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;
}

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

	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;

444
	args->csa_addr = svc_addr(rqstp);
445 446 447 448 449 450 451
	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) {
452 453 454
		args->csa_rclists = kmalloc_array(args->csa_nrclists,
						  sizeof(*args->csa_rclists),
						  GFP_KERNEL);
455 456 457 458 459
		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]);
460 461
			if (status) {
				args->csa_nrclists = i;
462
				goto out_free;
463
			}
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
		}
	}
	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;
}

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

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

	return 0;
}

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

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

521 522 523 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
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;
}

564 565
#endif /* CONFIG_NFS_V4_1 */

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

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

	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;
}

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

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

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

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

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

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

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

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

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

	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;
}

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

685
static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr, const struct cb_getattrres *res)
L
Linus Torvalds 已提交
686
{
687
	__be32 *savep = NULL;
688
	__be32 status = res->status;
L
Linus Torvalds 已提交
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
	
	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:
707
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
708 709 710
	return status;
}

711 712
#if defined(CONFIG_NFS_V4_1)

713
static __be32 encode_sessionid(struct xdr_stream *xdr,
714 715
				 const struct nfs4_sessionid *sid)
{
716
	__be32 *p;
717

718
	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN);
719 720 721
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);

722
	memcpy(p, sid, NFS4_MAX_SESSIONID_LEN);
723 724 725
	return 0;
}

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

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

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

	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;
}

753 754 755
static __be32
preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
{
756 757 758 759 760 761 762 763
	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);
	}

764 765 766
	switch (op_nr) {
	case OP_CB_GETATTR:
	case OP_CB_RECALL:
767
	case OP_CB_SEQUENCE:
768
	case OP_CB_RECALL_ANY:
A
Andy Adamson 已提交
769
	case OP_CB_RECALL_SLOT:
F
Fred Isaman 已提交
770
	case OP_CB_LAYOUTRECALL:
M
Marc Eshel 已提交
771
	case OP_CB_NOTIFY_DEVICEID:
772
	case OP_CB_NOTIFY_LOCK:
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
		*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);
}

789 790
static void nfs4_callback_free_slot(struct nfs4_session *session,
		struct nfs4_slot *slot)
791 792 793 794 795 796 797 798
{
	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
	 */
799
	nfs4_free_slot(tbl, slot);
800
	nfs4_slot_tbl_drain_complete(tbl);
801 802 803
	spin_unlock(&tbl->slot_tbl_lock);
}

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

812 813 814 815 816 817 818 819
#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);
}

820
static void nfs4_cb_free_slot(struct cb_process_state *cps)
821 822
{
}
823 824
#endif /* CONFIG_NFS_V4_1 */

825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
#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 */

845 846 847 848 849 850 851 852 853 854 855 856 857 858 859
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);
}

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

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

876
	dprintk("%s: minorversion=%d nop=%d op_nr=%u\n",
877
		__func__, cps->minorversion, nop, op_nr);
878

879 880 881 882 883 884 885 886 887 888 889 890 891
	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);
	}
892 893 894

	if (status == htonl(NFS4ERR_OP_ILLEGAL))
		op_nr = OP_CB_ILLEGAL;
895 896
	if (status)
		goto encode_hdr;
897

898 899
	if (cps->drc_status) {
		status = cps->drc_status;
900 901 902
		goto encode_hdr;
	}

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

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

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

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

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

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

944
	status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
945
	if (status == htonl(NFS4ERR_RESOURCE))
946 947
		return rpc_garbage_args;

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

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

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

966 967 968 969 970 971 972
	/* 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 已提交
973 974
	*hdr_res.status = status;
	*hdr_res.nops = htonl(nops);
975
	nfs4_cb_free_slot(&cps);
976
	nfs_put_client(cps.clp);
977
	dprintk("%s: done, status = %u\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
978
	return rpc_success;
979 980 981 982

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

/*
 * 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,
1002 1003
	},
#if defined(CONFIG_NFS_V4_1)
F
Fred Isaman 已提交
1004 1005 1006 1007 1008 1009
	[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 已提交
1010 1011 1012 1013 1014 1015
	[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,
	},
1016 1017 1018 1019 1020 1021
	[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,
	},
1022 1023 1024 1025 1026
	[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 已提交
1027 1028 1029 1030 1031
	[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,
	},
1032 1033 1034 1035 1036
	[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,
	},
1037
#endif /* CONFIG_NFS_V4_1 */
L
Linus Torvalds 已提交
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
};

/*
 * 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,
1065
	.vs_hidden = true,
1066
	.vs_need_cong_ctrl = true,
L
Linus Torvalds 已提交
1067 1068
};

1069 1070 1071 1072 1073 1074
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,
1075
	.vs_hidden = true,
1076
	.vs_need_cong_ctrl = true,
1077
};