NFS: Remove print_overflow_msg() (eb72f484) · Commits · e / devices / android_kernel_fairphone_FP5

fs/lockd/clnt4xdr.c

+0 −14

Original line number	Diff line number	Diff line
		@@ -74,17 +74,6 @@ static void nlm4_compute_offsets(const struct nlm_lock *lock,
		*l_len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
		}

		/*
		* Handle decode buffer overflows out-of-line.
		*/
		static void print_overflow_msg(const char func, const struct xdr_stream xdr)
		{
		dprintk("lockd: %s prematurely hit the end of our receive buffer. "
		"Remaining buffer length is %tu words.\n",
		func, xdr->end - xdr->p);
		}


		/*
		* Encode/decode NLMv4 basic data types
		*
		@@ -176,7 +165,6 @@ static int decode_cookie(struct xdr_stream *xdr,
		dprintk("NFS: returned cookie was too long: %u\n", length);
		return -EIO;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		@@ -236,7 +224,6 @@ static int decode_nlm4_stat(struct xdr_stream xdr, __be32 stat)
		__func__, be32_to_cpup(p));
		return -EIO;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		@@ -309,7 +296,6 @@ static int decode_nlm4_holder(struct xdr_stream xdr, struct nlm_res result)
		out:
		return error;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

fs/lockd/clntxdr.c

+0 −14

Original line number	Diff line number	Diff line
		@@ -70,17 +70,6 @@ static void nlm_compute_offsets(const struct nlm_lock *lock,
		*l_len = loff_t_to_s32(fl->fl_end - fl->fl_start + 1);
		}

		/*
		* Handle decode buffer overflows out-of-line.
		*/
		static void print_overflow_msg(const char func, const struct xdr_stream xdr)
		{
		dprintk("lockd: %s prematurely hit the end of our receive buffer. "
		"Remaining buffer length is %tu words.\n",
		func, xdr->end - xdr->p);
		}


		/*
		* Encode/decode NLMv3 basic data types
		*
		@@ -173,7 +162,6 @@ static int decode_cookie(struct xdr_stream *xdr,
		dprintk("NFS: returned cookie was too long: %u\n", length);
		return -EIO;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		@@ -231,7 +219,6 @@ static int decode_nlm_stat(struct xdr_stream *xdr,
		__func__, be32_to_cpup(p));
		return -EIO;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		@@ -303,7 +290,6 @@ static int decode_nlm_holder(struct xdr_stream xdr, struct nlm_res result)
		out:
		return error;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

fs/nfs/callback_xdr.c

+25 −34

Original line number	Diff line number	Diff line
		@@ -72,16 +72,6 @@ static int nfs4_encode_void(struct svc_rqst rqstp, __be32 p)
		return xdr_ressize_check(rqstp, p);
		}

		static __be32 read_buf(struct xdr_stream xdr, size_t nbytes)
		{
		__be32 *p;

		p = xdr_inline_decode(xdr, nbytes);
		if (unlikely(p == NULL))
		printk(KERN_WARNING "NFS: NFSv4 callback reply buffer overflowed!\n");
		return p;
		}

		static __be32 decode_string(struct xdr_stream xdr, unsigned int len,
		const char **str, size_t maxlen)
		{
		@@ -98,13 +88,13 @@ static __be32 decode_fh(struct xdr_stream xdr, struct nfs_fh fh)
		{
		__be32 *p;

		p = read_buf(xdr, 4);
		p = xdr_inline_decode(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);
		p = xdr_inline_decode(xdr, fh->size);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
		memcpy(&fh->data[0], p, fh->size);
		@@ -117,11 +107,11 @@ static __be32 decode_bitmap(struct xdr_stream xdr, uint32_t bitmap)
		__be32 *p;
		unsigned int attrlen;

		p = read_buf(xdr, 4);
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
		attrlen = ntohl(*p);
		p = read_buf(xdr, attrlen << 2);
		p = xdr_inline_decode(xdr, attrlen << 2);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
		if (likely(attrlen > 0))
		@@ -135,7 +125,7 @@ static __be32 decode_stateid(struct xdr_stream xdr, nfs4_stateid stateid)
		{
		__be32 *p;

		p = read_buf(xdr, NFS4_STATEID_SIZE);
		p = xdr_inline_decode(xdr, NFS4_STATEID_SIZE);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
		memcpy(stateid->data, p, NFS4_STATEID_SIZE);
		@@ -156,7 +146,7 @@ static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound
		status = decode_string(xdr, &hdr->taglen, &hdr->tag, CB_OP_TAGLEN_MAXSZ);
		if (unlikely(status != 0))
		return status;
		p = read_buf(xdr, 12);
		p = xdr_inline_decode(xdr, 12);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
		hdr->minorversion = ntohl(*p++);
		@@ -176,7 +166,7 @@ static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound
		static __be32 decode_op_hdr(struct xdr_stream xdr, unsigned int op)
		{
		__be32 *p;
		p = read_buf(xdr, 4);
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE_HDR);
		op = ntohl(p);
		@@ -205,7 +195,7 @@ static __be32 decode_recall_args(struct svc_rqst *rqstp,
		status = decode_delegation_stateid(xdr, &args->stateid);
		if (unlikely(status != 0))
		return status;
		p = read_buf(xdr, 4);
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
		args->truncate = ntohl(*p);
		@@ -227,7 +217,7 @@ static __be32 decode_layoutrecall_args(struct svc_rqst *rqstp,
		__be32 status = 0;
		uint32_t iomode;

		p = read_buf(xdr, 4 * sizeof(uint32_t));
		p = xdr_inline_decode(xdr, 4 * sizeof(uint32_t));
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);

		@@ -245,14 +235,14 @@ static __be32 decode_layoutrecall_args(struct svc_rqst *rqstp,
		if (unlikely(status != 0))
		return status;

		p = read_buf(xdr, 2 * sizeof(uint64_t));
		p = xdr_inline_decode(xdr, 2 * sizeof(uint64_t));
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);
		p = xdr_decode_hyper(p, &args->cbl_range.offset);
		p = xdr_decode_hyper(p, &args->cbl_range.length);
		return decode_layout_stateid(xdr, &args->cbl_stateid);
		} else if (args->cbl_recall_type == RETURN_FSID) {
		p = read_buf(xdr, 2 * sizeof(uint64_t));
		p = xdr_inline_decode(xdr, 2 * sizeof(uint64_t));
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);
		p = xdr_decode_hyper(p, &args->cbl_fsid.major);
		@@ -275,7 +265,7 @@ __be32 decode_devicenotify_args(struct svc_rqst *rqstp,
		args->ndevs = 0;

		/* Num of device notifications */
		p = read_buf(xdr, sizeof(uint32_t));
		p = xdr_inline_decode(xdr, sizeof(uint32_t));
		if (unlikely(p == NULL)) {
		status = htonl(NFS4ERR_BADXDR);
		goto out;
		@@ -298,7 +288,8 @@ __be32 decode_devicenotify_args(struct svc_rqst *rqstp,
		for (i = 0; i < n; i++) {
		struct cb_devicenotifyitem *dev = &args->devs[i];

		p = read_buf(xdr, (4 * sizeof(uint32_t)) + NFS4_DEVICEID4_SIZE);
		p = xdr_inline_decode(xdr, (4 * sizeof(uint32_t)) +
		NFS4_DEVICEID4_SIZE);
		if (unlikely(p == NULL)) {
		status = htonl(NFS4ERR_BADXDR);
		goto err;
		@@ -329,7 +320,7 @@ __be32 decode_devicenotify_args(struct svc_rqst *rqstp,
		p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);

		if (dev->cbd_layout_type == NOTIFY_DEVICEID4_CHANGE) {
		p = read_buf(xdr, sizeof(uint32_t));
		p = xdr_inline_decode(xdr, sizeof(uint32_t));
		if (unlikely(p == NULL)) {
		status = htonl(NFS4ERR_BADXDR);
		goto err;
		@@ -359,7 +350,7 @@ static __be32 decode_sessionid(struct xdr_stream *xdr,
		{
		__be32 *p;

		p = read_buf(xdr, NFS4_MAX_SESSIONID_LEN);
		p = xdr_inline_decode(xdr, NFS4_MAX_SESSIONID_LEN);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);

		@@ -379,13 +370,13 @@ static __be32 decode_rc_list(struct xdr_stream *xdr,
		goto out;

		status = htonl(NFS4ERR_RESOURCE);
		p = read_buf(xdr, sizeof(uint32_t));
		p = xdr_inline_decode(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,
		p = xdr_inline_decode(xdr,
		rc_list->rcl_nrefcalls * 2 * sizeof(uint32_t));
		if (unlikely(p == NULL))
		goto out;
		@@ -418,7 +409,7 @@ static __be32 decode_cb_sequence_args(struct svc_rqst *rqstp,
		if (status)
		return status;

		p = read_buf(xdr, 5 * sizeof(uint32_t));
		p = xdr_inline_decode(xdr, 5 * sizeof(uint32_t));
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);

		@@ -461,7 +452,7 @@ static __be32 decode_recallany_args(struct svc_rqst *rqstp,
		uint32_t bitmap[2];
		__be32 *p, status;

		p = read_buf(xdr, 4);
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);
		args->craa_objs_to_keep = ntohl(*p++);
		@@ -480,7 +471,7 @@ static __be32 decode_recallslot_args(struct svc_rqst *rqstp,
		struct cb_recallslotargs *args = argp;
		__be32 *p;

		p = read_buf(xdr, 4);
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);
		args->crsa_target_highest_slotid = ntohl(*p++);
		@@ -492,14 +483,14 @@ static __be32 decode_lockowner(struct xdr_stream *xdr, struct cb_notify_lock_arg
		__be32 *p;
		unsigned int len;

		p = read_buf(xdr, 12);
		p = xdr_inline_decode(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);
		p = xdr_inline_decode(xdr, len);
		if (unlikely(p == NULL))
		return htonl(NFS4ERR_BADXDR);

		@@ -537,7 +528,7 @@ static __be32 decode_write_response(struct xdr_stream *xdr,
		__be32 *p;

		/* skip the always zero field */
		p = read_buf(xdr, 4);
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(!p))
		goto out;
		p++;
		@@ -577,7 +568,7 @@ static __be32 decode_offload_args(struct svc_rqst *rqstp,
		return status;

		/* decode status */
		p = read_buf(xdr, 4);
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(!p))
		goto out;
		args->error = ntohl(*p++);

fs/nfs/nfs2xdr.c

+24 −60

Original line number	Diff line number	Diff line
		@@ -79,17 +79,6 @@ static void prepare_reply_buffer(struct rpc_rqst req, struct page *pages,
		xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
		}

		/*
		* Handle decode buffer overflows out-of-line.
		*/
		static void print_overflow_msg(const char func, const struct xdr_stream xdr)
		{
		dprintk("NFS: %s prematurely hit the end of our receive buffer. "
		"Remaining buffer length is %tu words.\n",
		func, xdr->end - xdr->p);
		}


		/*
		* Encode/decode NFSv2 basic data types
		*
		@@ -110,8 +99,8 @@ static int decode_nfsdata(struct xdr_stream xdr, struct nfs_pgio_res result)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		count = be32_to_cpup(p);
		recvd = xdr_read_pages(xdr, count);
		if (unlikely(count > recvd))
		@@ -125,9 +114,6 @@ static int decode_nfsdata(struct xdr_stream xdr, struct nfs_pgio_res result)
		"count %u > recvd %u\n", count, recvd);
		count = recvd;
		goto out;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -157,13 +143,10 @@ static int decode_stat(struct xdr_stream xdr, enum nfs_stat status)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		*status = be32_to_cpup(p);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -205,14 +188,11 @@ static int decode_fhandle(struct xdr_stream xdr, struct nfs_fh fh)
		__be32 *p;

		p = xdr_inline_decode(xdr, NFS2_FHSIZE);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		fh->size = NFS2_FHSIZE;
		memcpy(fh->data, p, NFS2_FHSIZE);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -282,8 +262,8 @@ static int decode_fattr(struct xdr_stream xdr, struct nfs_fattr fattr)
		__be32 *p;

		p = xdr_inline_decode(xdr, NFS_fattr_sz << 2);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;

		fattr->valid \|= NFS_ATTR_FATTR_V2;

		@@ -325,9 +305,6 @@ static int decode_fattr(struct xdr_stream xdr, struct nfs_fattr fattr)
		out_gid:
		dprintk("NFS: returned invalid gid\n");
		return -EINVAL;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -416,23 +393,20 @@ static int decode_filename_inline(struct xdr_stream *xdr,
		u32 count;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		count = be32_to_cpup(p);
		if (count > NFS3_MAXNAMLEN)
		goto out_nametoolong;
		p = xdr_inline_decode(xdr, count);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		name = (const char )p;
		*length = count;
		return 0;
		out_nametoolong:
		dprintk("NFS: returned filename too long: %u\n", count);
		return -ENAMETOOLONG;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -455,8 +429,8 @@ static int decode_path(struct xdr_stream *xdr)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		length = be32_to_cpup(p);
		if (unlikely(length >= xdr->buf->page_len \|\| length > NFS_MAXPATHLEN))
		goto out_size;
		@@ -472,9 +446,6 @@ static int decode_path(struct xdr_stream *xdr)
		dprintk("NFS: server cheating in pathname result: "
		"length %u > received %u\n", length, recvd);
		return -EIO;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -951,12 +922,12 @@ int nfs2_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,
		int error;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EAGAIN;
		if (*p++ == xdr_zero) {
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EAGAIN;
		if (*p++ == xdr_zero)
		return -EAGAIN;
		entry->eof = 1;
		@@ -964,8 +935,8 @@ int nfs2_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,
		}

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EAGAIN;
		entry->ino = be32_to_cpup(p);

		error = decode_filename_inline(xdr, &entry->name, &entry->len);
		@@ -978,17 +949,13 @@ int nfs2_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,
		*/
		entry->prev_cookie = entry->cookie;
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EAGAIN;
		entry->cookie = be32_to_cpup(p);

		entry->d_type = DT_UNKNOWN;

		return 0;

		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EAGAIN;
		}

		/*
		@@ -1052,17 +1019,14 @@ static int decode_info(struct xdr_stream xdr, struct nfs2_fsstat result)
		__be32 *p;

		p = xdr_inline_decode(xdr, NFS_info_sz << 2);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		result->tsize = be32_to_cpup(p++);
		result->bsize = be32_to_cpup(p++);
		result->blocks = be32_to_cpup(p++);
		result->bfree = be32_to_cpup(p++);
		result->bavail = be32_to_cpup(p);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static int nfs2_xdr_dec_statfsres(struct rpc_rqst req, struct xdr_stream xdr,

fs/nfs/nfs3xdr.c

+47 −116

Original line number	Diff line number	Diff line
		@@ -118,17 +118,6 @@ static void prepare_reply_buffer(struct rpc_rqst req, struct page *pages,
		xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
		}

		/*
		* Handle decode buffer overflows out-of-line.
		*/
		static void print_overflow_msg(const char func, const struct xdr_stream xdr)
		{
		dprintk("NFS: %s prematurely hit the end of our receive buffer. "
		"Remaining buffer length is %tu words.\n",
		func, xdr->end - xdr->p);
		}


		/*
		* Encode/decode NFSv3 basic data types
		*
		@@ -151,13 +140,10 @@ static int decode_uint32(struct xdr_stream xdr, u32 value)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		*value = be32_to_cpup(p);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static int decode_uint64(struct xdr_stream xdr, u64 value)
		@@ -165,13 +151,10 @@ static int decode_uint64(struct xdr_stream xdr, u64 value)
		__be32 *p;

		p = xdr_inline_decode(xdr, 8);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		xdr_decode_hyper(p, value);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -211,14 +194,14 @@ static int decode_inline_filename3(struct xdr_stream *xdr,
		u32 count;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		count = be32_to_cpup(p);
		if (count > NFS3_MAXNAMLEN)
		goto out_nametoolong;
		p = xdr_inline_decode(xdr, count);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		name = (const char )p;
		*length = count;
		return 0;
		@@ -226,9 +209,6 @@ static int decode_inline_filename3(struct xdr_stream *xdr,
		out_nametoolong:
		dprintk("NFS: returned filename too long: %u\n", count);
		return -ENAMETOOLONG;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -249,8 +229,8 @@ static int decode_nfspath3(struct xdr_stream *xdr)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		count = be32_to_cpup(p);
		if (unlikely(count >= xdr->buf->page_len \|\| count > NFS3_MAXPATHLEN))
		goto out_nametoolong;
		@@ -267,9 +247,6 @@ static int decode_nfspath3(struct xdr_stream *xdr)
		dprintk("NFS: server cheating in pathname result: "
		"count %u > recvd %u\n", count, recvd);
		return -EIO;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -303,13 +280,10 @@ static int decode_cookieverf3(struct xdr_stream xdr, __be32 verifier)
		__be32 *p;

		p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		memcpy(verifier, p, NFS3_COOKIEVERFSIZE);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -330,13 +304,10 @@ static int decode_writeverf3(struct xdr_stream xdr, struct nfs_write_verifier
		__be32 *p;

		p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		memcpy(verifier->data, p, NFS3_WRITEVERFSIZE);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -364,13 +335,10 @@ static int decode_nfsstat3(struct xdr_stream xdr, enum nfs_stat status)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		*status = be32_to_cpup(p);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -453,23 +421,20 @@ static int decode_nfs_fh3(struct xdr_stream xdr, struct nfs_fh fh)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		length = be32_to_cpup(p++);
		if (unlikely(length > NFS3_FHSIZE))
		goto out_toobig;
		p = xdr_inline_decode(xdr, length);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		fh->size = length;
		memcpy(fh->data, p, length);
		return 0;
		out_toobig:
		dprintk("NFS: file handle size (%u) too big\n", length);
		return -E2BIG;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static void zero_nfs_fh3(struct nfs_fh *fh)
		@@ -655,8 +620,8 @@ static int decode_fattr3(struct xdr_stream xdr, struct nfs_fattr fattr)
		__be32 *p;

		p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;

		p = xdr_decode_ftype3(p, &fmode);

		@@ -690,9 +655,6 @@ static int decode_fattr3(struct xdr_stream xdr, struct nfs_fattr fattr)
		out_gid:
		dprintk("NFS: returned invalid gid\n");
		return -EINVAL;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -710,14 +672,11 @@ static int decode_post_op_attr(struct xdr_stream xdr, struct nfs_fattr fattr)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		if (*p != xdr_zero)
		return decode_fattr3(xdr, fattr);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -733,8 +692,8 @@ static int decode_wcc_attr(struct xdr_stream xdr, struct nfs_fattr fattr)
		__be32 *p;

		p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;

		fattr->valid \|= NFS_ATTR_FATTR_PRESIZE
		\| NFS_ATTR_FATTR_PRECHANGE
		@@ -747,9 +706,6 @@ static int decode_wcc_attr(struct xdr_stream xdr, struct nfs_fattr fattr)
		fattr->pre_change_attr = nfs_timespec_to_change_attr(&fattr->pre_ctime);

		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -773,14 +729,11 @@ static int decode_pre_op_attr(struct xdr_stream xdr, struct nfs_fattr fattr)
		__be32 *p;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		if (*p != xdr_zero)
		return decode_wcc_attr(xdr, fattr);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static int decode_wcc_data(struct xdr_stream xdr, struct nfs_fattr fattr)
		@@ -808,15 +761,12 @@ static int decode_wcc_data(struct xdr_stream xdr, struct nfs_fattr fattr)
		static int decode_post_op_fh3(struct xdr_stream xdr, struct nfs_fh fh)
		{
		__be32 *p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		if (*p != xdr_zero)
		return decode_nfs_fh3(xdr, fh);
		zero_nfs_fh3(fh);
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		/*
		@@ -1643,8 +1593,8 @@ static int decode_read3resok(struct xdr_stream *xdr,
		__be32 *p;

		p = xdr_inline_decode(xdr, 4 + 4 + 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		count = be32_to_cpup(p++);
		eof = be32_to_cpup(p++);
		ocount = be32_to_cpup(p++);
		@@ -1667,9 +1617,6 @@ static int decode_read3resok(struct xdr_stream *xdr,
		count = recvd;
		eof = 0;
		goto out;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static int nfs3_xdr_dec_read3res(struct rpc_rqst req, struct xdr_stream xdr,
		@@ -1731,22 +1678,18 @@ static int decode_write3resok(struct xdr_stream *xdr,
		__be32 *p;

		p = xdr_inline_decode(xdr, 4 + 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		result->count = be32_to_cpup(p++);
		result->verf->committed = be32_to_cpup(p++);
		if (unlikely(result->verf->committed > NFS_FILE_SYNC))
		goto out_badvalue;
		if (decode_writeverf3(xdr, &result->verf->verifier))
		goto out_eio;
		return -EIO;
		return result->count;
		out_badvalue:
		dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
		return -EIO;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		out_eio:
		return -EIO;
		}

		static int nfs3_xdr_dec_write3res(struct rpc_rqst req, struct xdr_stream xdr,
		@@ -2010,12 +1953,12 @@ int nfs3_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,
		u64 new_cookie;

		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EAGAIN;
		if (*p == xdr_zero) {
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EAGAIN;
		if (*p == xdr_zero)
		return -EAGAIN;
		entry->eof = 1;
		@@ -2051,8 +1994,8 @@ int nfs3_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,

		/* In fact, a post_op_fh3: */
		p = xdr_inline_decode(xdr, 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EAGAIN;
		if (*p != xdr_zero) {
		error = decode_nfs_fh3(xdr, entry->fh);
		if (unlikely(error)) {
		@@ -2069,9 +2012,6 @@ int nfs3_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,

		return 0;

		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EAGAIN;
		out_truncated:
		dprintk("NFS: directory entry contains invalid file handle\n");
		*entry = old;
		@@ -2183,8 +2123,8 @@ static int decode_fsstat3resok(struct xdr_stream *xdr,
		__be32 *p;

		p = xdr_inline_decode(xdr, 8 * 6 + 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		p = xdr_decode_size3(p, &result->tbytes);
		p = xdr_decode_size3(p, &result->fbytes);
		p = xdr_decode_size3(p, &result->abytes);
		@@ -2193,9 +2133,6 @@ static int decode_fsstat3resok(struct xdr_stream *xdr,
		xdr_decode_size3(p, &result->afiles);
		/* ignore invarsec */
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
		@@ -2255,8 +2192,8 @@ static int decode_fsinfo3resok(struct xdr_stream *xdr,
		__be32 *p;

		p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		result->rtmax = be32_to_cpup(p++);
		result->rtpref = be32_to_cpup(p++);
		result->rtmult = be32_to_cpup(p++);
		@@ -2270,9 +2207,6 @@ static int decode_fsinfo3resok(struct xdr_stream *xdr,
		/* ignore properties */
		result->lease_time = 0;
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
		@@ -2328,15 +2262,12 @@ static int decode_pathconf3resok(struct xdr_stream *xdr,
		__be32 *p;

		p = xdr_inline_decode(xdr, 4 * 6);
		if (unlikely(p == NULL))
		goto out_overflow;
		if (unlikely(!p))
		return -EIO;
		result->max_link = be32_to_cpup(p++);
		result->max_namelen = be32_to_cpup(p);
		/* ignore remaining fields */
		return 0;
		out_overflow:
		print_overflow_msg(__func__, xdr);
		return -EIO;
		}

		static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,