callback_xdr.c 26.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 39
#endif /* CONFIG_NFS_V4_1 */

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

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

45 46
typedef __be32 (*callback_process_op_t)(void *, void *,
					struct cb_process_state *);
47 48
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 已提交
49 50 51 52 53 54 55 56 57 58 59


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 已提交
60
static __be32 nfs4_callback_null(struct svc_rqst *rqstp, void *argp, void *resp)
L
Linus Torvalds 已提交
61 62 63 64
{
	return htonl(NFS4_OK);
}

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

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

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

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

85
static __be32 decode_string(struct xdr_stream *xdr, unsigned int *len, const char **str)
L
Linus Torvalds 已提交
86
{
87
	__be32 *p;
L
Linus Torvalds 已提交
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	*len = ntohl(*p);

	if (*len != 0) {
		p = read_buf(xdr, *len);
		if (unlikely(p == NULL))
			return htonl(NFS4ERR_RESOURCE);
		*str = (const char *)p;
	} else
		*str = NULL;

	return 0;
}

105
static __be32 decode_fh(struct xdr_stream *xdr, struct nfs_fh *fh)
L
Linus Torvalds 已提交
106
{
107
	__be32 *p;
L
Linus Torvalds 已提交
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

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

123
static __be32 decode_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
L
Linus Torvalds 已提交
124
{
125
	__be32 *p;
L
Linus Torvalds 已提交
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
	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;
}

142
static __be32 decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
L
Linus Torvalds 已提交
143
{
144
	__be32 *p;
L
Linus Torvalds 已提交
145

146
	p = read_buf(xdr, NFS4_STATEID_SIZE);
L
Linus Torvalds 已提交
147 148
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
149
	memcpy(stateid->data, p, NFS4_STATEID_SIZE);
L
Linus Torvalds 已提交
150 151 152
	return 0;
}

153 154 155 156 157 158
static __be32 decode_delegation_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
{
	stateid->type = NFS4_DELEGATION_STATEID_TYPE;
	return decode_stateid(xdr, stateid);
}

159
static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound_hdr_arg *hdr)
L
Linus Torvalds 已提交
160
{
161
	__be32 *p;
162
	__be32 status;
L
Linus Torvalds 已提交
163 164 165 166 167

	status = decode_string(xdr, &hdr->taglen, &hdr->tag);
	if (unlikely(status != 0))
		return status;
	/* We do not like overly long tags! */
168
	if (hdr->taglen > CB_OP_TAGLEN_MAXSZ) {
169
		printk("NFS: NFSv4 CALLBACK %s: client sent tag of length %u\n",
170
				__func__, hdr->taglen);
L
Linus Torvalds 已提交
171 172 173 174 175
		return htonl(NFS4ERR_RESOURCE);
	}
	p = read_buf(xdr, 12);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
176
	hdr->minorversion = ntohl(*p++);
177 178
	/* Check for minor version support */
	if (hdr->minorversion <= NFS4_MAX_MINOR_VERSION) {
179
		hdr->cb_ident = ntohl(*p++); /* ignored by v4.1 and v4.2 */
180
	} else {
181
		pr_warn_ratelimited("NFS: %s: NFSv4 server callback with "
182 183
			"illegal minor version %u!\n",
			__func__, hdr->minorversion);
L
Linus Torvalds 已提交
184 185 186
		return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
	}
	hdr->nops = ntohl(*p);
187 188
	dprintk("%s: minorversion %d nops %d\n", __func__,
		hdr->minorversion, hdr->nops);
L
Linus Torvalds 已提交
189 190 191
	return 0;
}

192
static __be32 decode_op_hdr(struct xdr_stream *xdr, unsigned int *op)
L
Linus Torvalds 已提交
193
{
194
	__be32 *p;
L
Linus Torvalds 已提交
195 196
	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
197
		return htonl(NFS4ERR_RESOURCE_HDR);
L
Linus Torvalds 已提交
198 199 200 201
	*op = ntohl(*p);
	return 0;
}

202
static __be32 decode_getattr_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_getattrargs *args)
L
Linus Torvalds 已提交
203
{
204
	__be32 status;
L
Linus Torvalds 已提交
205 206 207 208 209 210

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

215
static __be32 decode_recall_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_recallargs *args)
L
Linus Torvalds 已提交
216
{
217
	__be32 *p;
218
	__be32 status;
L
Linus Torvalds 已提交
219

220
	status = decode_delegation_stateid(xdr, &args->stateid);
L
Linus Torvalds 已提交
221 222 223 224 225 226 227 228 229 230
	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:
231
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
232
	return status;
L
Linus Torvalds 已提交
233 234
}

235
#if defined(CONFIG_NFS_V4_1)
236 237 238 239 240
static __be32 decode_layout_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
{
	stateid->type = NFS4_LAYOUT_STATEID_TYPE;
	return decode_stateid(xdr, stateid);
}
241

F
Fred Isaman 已提交
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
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 已提交
258
	 * as it is unusable and ignored with the other types.
F
Fred Isaman 已提交
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
	 */
	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);
277
		status = decode_layout_stateid(xdr, &args->cbl_stateid);
F
Fred Isaman 已提交
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
		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 已提交
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
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;
321 322 323 324
	if (n > ULONG_MAX / sizeof(*args->devs)) {
		status = htonl(NFS4ERR_BADXDR);
		goto out;
	}
M
Marc Eshel 已提交
325

326
	args->devs = kmalloc_array(n, sizeof(*args->devs), GFP_KERNEL);
M
Marc Eshel 已提交
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 379 380 381 382 383 384 385 386 387 388 389 390 391
	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;
}

392
static __be32 decode_sessionid(struct xdr_stream *xdr,
393 394
				 struct nfs4_sessionid *sid)
{
395
	__be32 *p;
396

397
	p = read_buf(xdr, NFS4_MAX_SESSIONID_LEN);
398
	if (unlikely(p == NULL))
399
		return htonl(NFS4ERR_RESOURCE);
400

401
	memcpy(sid->data, p, NFS4_MAX_SESSIONID_LEN);
402 403 404
	return 0;
}

405
static __be32 decode_rc_list(struct xdr_stream *xdr,
406 407
			       struct referring_call_list *rc_list)
{
408
	__be32 *p;
409
	int i;
410
	__be32 status;
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426

	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;
427
		rc_list->rcl_refcalls = kmalloc_array(rc_list->rcl_nrefcalls,
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
						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;
}

443
static __be32 decode_cb_sequence_args(struct svc_rqst *rqstp,
444 445 446
					struct xdr_stream *xdr,
					struct cb_sequenceargs *args)
{
447
	__be32 *p;
448
	int i;
449
	__be32 status;
450 451 452 453 454 455 456 457 458 459

	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;

460
	args->csa_addr = svc_addr(rqstp);
461 462 463 464 465 466 467
	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) {
468 469 470
		args->csa_rclists = kmalloc_array(args->csa_nrclists,
						  sizeof(*args->csa_rclists),
						  GFP_KERNEL);
471 472 473 474 475
		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]);
476 477
			if (status) {
				args->csa_nrclists = i;
478
				goto out_free;
479
			}
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
		}
	}
	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;
}

505
static __be32 decode_recallany_args(struct svc_rqst *rqstp,
506 507 508
				      struct xdr_stream *xdr,
				      struct cb_recallanyargs *args)
{
P
Peng Tao 已提交
509 510
	uint32_t bitmap[2];
	__be32 *p, status;
511 512 513 514 515

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);
	args->craa_objs_to_keep = ntohl(*p++);
P
Peng Tao 已提交
516 517 518 519
	status = decode_bitmap(xdr, bitmap);
	if (unlikely(status))
		return status;
	args->craa_type_mask = bitmap[0];
520 521 522 523

	return 0;
}

524
static __be32 decode_recallslot_args(struct svc_rqst *rqstp,
A
Andy Adamson 已提交
525 526 527 528 529 530 531 532
					struct xdr_stream *xdr,
					struct cb_recallslotargs *args)
{
	__be32 *p;

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);
533
	args->crsa_target_highest_slotid = ntohl(*p++);
A
Andy Adamson 已提交
534 535 536
	return 0;
}

537 538
#endif /* CONFIG_NFS_V4_1 */

539
static __be32 encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
L
Linus Torvalds 已提交
540
{
541
	__be32 *p;
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549 550 551

	p = xdr_reserve_space(xdr, 4 + len);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	xdr_encode_opaque(p, str, len);
	return 0;
}

#define CB_SUPPORTED_ATTR0 (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE)
#define CB_SUPPORTED_ATTR1 (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY)
552
static __be32 encode_attr_bitmap(struct xdr_stream *xdr, const uint32_t *bitmap, __be32 **savep)
L
Linus Torvalds 已提交
553
{
554 555
	__be32 bm[2];
	__be32 *p;
L
Linus Torvalds 已提交
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581

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

582
static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t change)
L
Linus Torvalds 已提交
583
{
584
	__be32 *p;
L
Linus Torvalds 已提交
585 586 587 588

	if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
		return 0;
	p = xdr_reserve_space(xdr, 8);
H
Harvey Harrison 已提交
589
	if (unlikely(!p))
L
Linus Torvalds 已提交
590 591 592 593 594
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, change);
	return 0;
}

595
static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t size)
L
Linus Torvalds 已提交
596
{
597
	__be32 *p;
L
Linus Torvalds 已提交
598 599 600 601

	if (!(bitmap[0] & FATTR4_WORD0_SIZE))
		return 0;
	p = xdr_reserve_space(xdr, 8);
H
Harvey Harrison 已提交
602
	if (unlikely(!p))
L
Linus Torvalds 已提交
603 604 605 606 607
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, size);
	return 0;
}

608
static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec *time)
L
Linus Torvalds 已提交
609
{
610
	__be32 *p;
L
Linus Torvalds 已提交
611 612

	p = xdr_reserve_space(xdr, 12);
H
Harvey Harrison 已提交
613
	if (unlikely(!p))
L
Linus Torvalds 已提交
614 615 616 617 618 619
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, time->tv_sec);
	*p = htonl(time->tv_nsec);
	return 0;
}

620
static __be32 encode_attr_ctime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec *time)
L
Linus Torvalds 已提交
621 622 623 624 625 626
{
	if (!(bitmap[1] & FATTR4_WORD1_TIME_METADATA))
		return 0;
	return encode_attr_time(xdr,time);
}

627
static __be32 encode_attr_mtime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec *time)
L
Linus Torvalds 已提交
628 629 630 631 632 633
{
	if (!(bitmap[1] & FATTR4_WORD1_TIME_MODIFY))
		return 0;
	return encode_attr_time(xdr,time);
}

634
static __be32 encode_compound_hdr_res(struct xdr_stream *xdr, struct cb_compound_hdr_res *hdr)
L
Linus Torvalds 已提交
635
{
636
	__be32 status;
L
Linus Torvalds 已提交
637 638 639 640 641 642 643 644 645 646 647 648 649

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

650
static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res)
L
Linus Torvalds 已提交
651
{
652
	__be32 *p;
L
Linus Torvalds 已提交
653 654 655
	
	p = xdr_reserve_space(xdr, 8);
	if (unlikely(p == NULL))
656
		return htonl(NFS4ERR_RESOURCE_HDR);
L
Linus Torvalds 已提交
657 658 659 660 661
	*p++ = htonl(op);
	*p = res;
	return 0;
}

662
static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr, const struct cb_getattrres *res)
L
Linus Torvalds 已提交
663
{
664
	__be32 *savep = NULL;
665
	__be32 status = res->status;
L
Linus Torvalds 已提交
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
	
	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:
684
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
685 686 687
	return status;
}

688 689
#if defined(CONFIG_NFS_V4_1)

690
static __be32 encode_sessionid(struct xdr_stream *xdr,
691 692
				 const struct nfs4_sessionid *sid)
{
693
	__be32 *p;
694

695
	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN);
696 697 698
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);

699
	memcpy(p, sid, NFS4_MAX_SESSIONID_LEN);
700 701 702
	return 0;
}

703
static __be32 encode_cb_sequence_res(struct svc_rqst *rqstp,
704 705 706
				       struct xdr_stream *xdr,
				       const struct cb_sequenceres *res)
{
707
	__be32 *p;
708
	__be32 status = res->csr_status;
709 710 711 712

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

713 714 715
	status = encode_sessionid(xdr, &res->csr_sessionid);
	if (status)
		goto out;
716 717 718 719 720 721 722 723 724 725 726 727 728 729

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

730 731 732
static __be32
preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
{
733 734 735 736 737 738 739 740
	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);
	}

741 742 743
	switch (op_nr) {
	case OP_CB_GETATTR:
	case OP_CB_RECALL:
744
	case OP_CB_SEQUENCE:
745
	case OP_CB_RECALL_ANY:
A
Andy Adamson 已提交
746
	case OP_CB_RECALL_SLOT:
F
Fred Isaman 已提交
747
	case OP_CB_LAYOUTRECALL:
M
Marc Eshel 已提交
748
	case OP_CB_NOTIFY_DEVICEID:
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
		*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:
	case OP_CB_NOTIFY_LOCK:
		return htonl(NFS4ERR_NOTSUPP);

	default:
		return htonl(NFS4ERR_OP_ILLEGAL);
	}

	return htonl(NFS_OK);
}

766 767
static void nfs4_callback_free_slot(struct nfs4_session *session,
		struct nfs4_slot *slot)
768 769 770 771 772 773 774 775
{
	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
	 */
776
	nfs4_free_slot(tbl, slot);
777
	nfs4_slot_tbl_drain_complete(tbl);
778 779 780
	spin_unlock(&tbl->slot_tbl_lock);
}

781
static void nfs4_cb_free_slot(struct cb_process_state *cps)
782
{
783 784 785 786
	if (cps->slot) {
		nfs4_callback_free_slot(cps->clp->cl_session, cps->slot);
		cps->slot = NULL;
	}
787 788
}

789 790 791 792 793 794 795 796
#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);
}

797
static void nfs4_cb_free_slot(struct cb_process_state *cps)
798 799
{
}
800 801
#endif /* CONFIG_NFS_V4_1 */

802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
#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 */

822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
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);
}

837
static __be32 process_op(int nop, struct svc_rqst *rqstp,
L
Linus Torvalds 已提交
838
		struct xdr_stream *xdr_in, void *argp,
839 840
		struct xdr_stream *xdr_out, void *resp,
		struct cb_process_state *cps)
L
Linus Torvalds 已提交
841
{
842
	struct callback_op *op = &callback_ops[0];
843
	unsigned int op_nr;
844
	__be32 status;
L
Linus Torvalds 已提交
845
	long maxlen;
846
	__be32 res;
L
Linus Torvalds 已提交
847

848
	dprintk("%s: start\n", __func__);
L
Linus Torvalds 已提交
849
	status = decode_op_hdr(xdr_in, &op_nr);
850 851
	if (unlikely(status))
		return status;
L
Linus Torvalds 已提交
852

853
	dprintk("%s: minorversion=%d nop=%d op_nr=%u\n",
854
		__func__, cps->minorversion, nop, op_nr);
855

856 857 858 859 860 861 862 863 864 865 866 867 868
	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);
	}
869 870 871

	if (status == htonl(NFS4ERR_OP_ILLEGAL))
		op_nr = OP_CB_ILLEGAL;
872 873
	if (status)
		goto encode_hdr;
874

875 876
	if (cps->drc_status) {
		status = cps->drc_status;
877 878 879
		goto encode_hdr;
	}

L
Linus Torvalds 已提交
880 881
	maxlen = xdr_out->end - xdr_out->p;
	if (maxlen > 0 && maxlen < PAGE_SIZE) {
882 883
		status = op->decode_args(rqstp, xdr_in, argp);
		if (likely(status == 0))
884
			status = op->process_op(argp, resp, cps);
L
Linus Torvalds 已提交
885 886 887
	} else
		status = htonl(NFS4ERR_RESOURCE);

888
encode_hdr:
L
Linus Torvalds 已提交
889
	res = encode_op_hdr(xdr_out, op_nr, status);
890 891
	if (unlikely(res))
		return res;
L
Linus Torvalds 已提交
892 893
	if (op->encode_res != NULL && status == 0)
		status = op->encode_res(rqstp, xdr_out, resp);
894
	dprintk("%s: done, status = %d\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
895 896 897 898 899 900
	return status;
}

/*
 * Decode, process and encode a COMPOUND
 */
A
Al Viro 已提交
901
static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
L
Linus Torvalds 已提交
902
{
903 904
	struct cb_compound_hdr_arg hdr_arg = { 0 };
	struct cb_compound_hdr_res hdr_res = { NULL };
L
Linus Torvalds 已提交
905
	struct xdr_stream xdr_in, xdr_out;
906 907 908 909
	__be32 *p, status;
	struct cb_process_state cps = {
		.drc_status = 0,
		.clp = NULL,
910
		.net = SVC_NET(rqstp),
911
	};
912
	unsigned int nops = 0;
L
Linus Torvalds 已提交
913

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

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

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

921
	status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
922
	if (status == htonl(NFS4ERR_RESOURCE))
923 924
		return rpc_garbage_args;

925
	if (hdr_arg.minorversion == 0) {
926
		cps.clp = nfs4_find_client_ident(SVC_NET(rqstp), hdr_arg.cb_ident);
927
		if (!cps.clp || !check_gss_callback_principal(cps.clp, rqstp))
928
			goto out_invalidcred;
929
	}
930

931
	cps.minorversion = hdr_arg.minorversion;
L
Linus Torvalds 已提交
932 933
	hdr_res.taglen = hdr_arg.taglen;
	hdr_res.tag = hdr_arg.tag;
934 935
	if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
		return rpc_system_err;
L
Linus Torvalds 已提交
936

937
	while (status == 0 && nops != hdr_arg.nops) {
938 939
		status = process_op(nops, rqstp, &xdr_in,
				    argp, &xdr_out, resp, &cps);
L
Linus Torvalds 已提交
940 941
		nops++;
	}
942

943 944 945 946 947 948 949
	/* 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 已提交
950 951
	*hdr_res.status = status;
	*hdr_res.nops = htonl(nops);
952
	nfs4_cb_free_slot(&cps);
953
	nfs_put_client(cps.clp);
954
	dprintk("%s: done, status = %u\n", __func__, ntohl(status));
L
Linus Torvalds 已提交
955
	return rpc_success;
956 957 958 959

out_invalidcred:
	pr_warn_ratelimited("NFS: NFSv4 callback contains invalid cred\n");
	return rpc_autherr_badcred;
L
Linus Torvalds 已提交
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
}

/*
 * 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,
979 980
	},
#if defined(CONFIG_NFS_V4_1)
F
Fred Isaman 已提交
981 982 983 984 985 986
	[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 已提交
987 988 989 990 991 992
	[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,
	},
993 994 995 996 997 998
	[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,
	},
999 1000 1001 1002 1003
	[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 已提交
1004 1005 1006 1007 1008
	[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,
	},
1009
#endif /* CONFIG_NFS_V4_1 */
L
Linus Torvalds 已提交
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
};

/*
 * 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,
1037
	.vs_hidden = 1,
L
Linus Torvalds 已提交
1038 1039
};

1040 1041 1042 1043 1044 1045
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,
1046
	.vs_hidden = 1,
1047
};