forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2024-05-16 8d2a02b24d66aa359e83eebc1ed3c0f85367a1cb 
 kernel/fs/nfs/nfs4xdr.c
....@@ -54,6 +54,7 @@
5454 #include <linux/nfs_fs.h>
5555 
5656 #include "nfs4_fs.h"
57
+#include "nfs4trace.h"
5758 #include "internal.h"
5859 #include "nfs4idmap.h"
5960 #include "nfs4session.h"
....@@ -214,14 +215,14 @@
214215 				 nfs4_fattr_bitmap_maxsz)
215216 #define encode_read_maxsz	(op_encode_hdr_maxsz + \
216217 				 encode_stateid_maxsz + 3)
217
-#define decode_read_maxsz	(op_decode_hdr_maxsz + 2)
218
+#define decode_read_maxsz	(op_decode_hdr_maxsz + 2 + 1)
218219 #define encode_readdir_maxsz	(op_encode_hdr_maxsz + \
219220 				 2 + encode_verifier_maxsz + 5 + \
220221 				nfs4_label_maxsz)
221222 #define decode_readdir_maxsz	(op_decode_hdr_maxsz + \
222
-				 decode_verifier_maxsz)
223
+				 decode_verifier_maxsz + 1)
223224 #define encode_readlink_maxsz	(op_encode_hdr_maxsz)
224
-#define decode_readlink_maxsz	(op_decode_hdr_maxsz + 1)
225
+#define decode_readlink_maxsz	(op_decode_hdr_maxsz + 1 + 1)
225226 #define encode_write_maxsz	(op_encode_hdr_maxsz + \
226227 				 encode_stateid_maxsz + 4)
227228 #define decode_write_maxsz	(op_decode_hdr_maxsz + \
....@@ -283,14 +284,14 @@
283284 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
284285 #define encode_getacl_maxsz	(encode_getattr_maxsz)
285286 #define decode_getacl_maxsz	(op_decode_hdr_maxsz + \
286
-				 nfs4_fattr_bitmap_maxsz + 1)
287
+				 nfs4_fattr_bitmap_maxsz + 1 + 1)
287288 #define encode_setacl_maxsz	(op_encode_hdr_maxsz + \
288289 				 encode_stateid_maxsz + 3)
289290 #define decode_setacl_maxsz	(decode_setattr_maxsz)
290291 #define encode_fs_locations_maxsz \
291292 				(encode_getattr_maxsz)
292293 #define decode_fs_locations_maxsz \
293
-				(0)
294
+				(1)
294295 #define encode_secinfo_maxsz	(op_encode_hdr_maxsz + nfs4_name_maxsz)
295296 #define decode_secinfo_maxsz	(op_decode_hdr_maxsz + 1 + ((NFS_MAX_SECFLAVORS * (16 + GSS_OID_MAX_LEN)) / 4))
296297 
....@@ -391,12 +392,13 @@
391392 				1 /* opaque devaddr4 length */ + \
392393 				  /* devaddr4 payload is read into page */ \
393394 				1 /* notification bitmap length */ + \
394
-				1 /* notification bitmap, word 0 */)
395
+				1 /* notification bitmap, word 0 */ + \
396
+				1 /* possible XDR padding */)
395397 #define encode_layoutget_maxsz	(op_encode_hdr_maxsz + 10 + \
396398 				encode_stateid_maxsz)
397399 #define decode_layoutget_maxsz	(op_decode_hdr_maxsz + 8 + \
398400 				decode_stateid_maxsz + \
399
-				XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE))
401
+				XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE) + 1)
400402 #define encode_layoutcommit_maxsz (op_encode_hdr_maxsz +          \
401403 				2 /* offset */ + \
402404 				2 /* length */ + \
....@@ -835,6 +837,7 @@
835837 #define NFS4_dec_sequence_sz \
836838 				(compound_decode_hdr_maxsz + \
837839 				 decode_sequence_maxsz)
840
+#endif
838841 #define NFS4_enc_get_lease_time_sz	(compound_encode_hdr_maxsz + \
839842 					 encode_sequence_maxsz + \
840843 					 encode_putrootfh_maxsz + \
....@@ -843,6 +846,7 @@
843846 					 decode_sequence_maxsz + \
844847 					 decode_putrootfh_maxsz + \
845848 					 decode_fsinfo_maxsz)
849
+#if defined(CONFIG_NFS_V4_1)
846850 #define NFS4_enc_reclaim_complete_sz	(compound_encode_hdr_maxsz + \
847851 					 encode_sequence_maxsz + \
848852 					 encode_reclaim_complete_maxsz)
....@@ -1015,12 +1019,11 @@
10151019 				struct compound_hdr *hdr)
10161020 {
10171021 	__be32 *p;
1018
-	struct rpc_auth *auth = req->rq_cred->cr_auth;
10191022 
10201023 	/* initialize running count of expected bytes in reply.
10211024 	 * NOTE: the replied tag SHOULD be the same is the one sent,
10221025 	 * but this is not required as a MUST for the server to do so. */
1023
-	hdr->replen = RPC_REPHDRSIZE + auth->au_rslack + 3 + hdr->taglen;
1026
+	hdr->replen = 3 + hdr->taglen;
10241027 
10251028 	WARN_ON_ONCE(hdr->taglen > NFS4_MAXTAGLEN);
10261029 	encode_string(xdr, hdr->taglen, hdr->tag);
....@@ -1056,9 +1059,9 @@
10561059 }
10571060 
10581061 static __be32 *
1059
-xdr_encode_nfstime4(__be32 *p, const struct timespec *t)
1062
+xdr_encode_nfstime4(__be32 *p, const struct timespec64 *t)
10601063 {
1061
-	p = xdr_encode_hyper(p, (__s64)t->tv_sec);
1064
+	p = xdr_encode_hyper(p, t->tv_sec);
10621065 	*p++ = cpu_to_be32(t->tv_nsec);
10631066 	return p;
10641067 }
....@@ -1069,7 +1072,6 @@
10691072 				const struct nfs_server *server,
10701073 				const uint32_t attrmask[])
10711074 {
1072
-	struct timespec ts;
10731075 	char owner_name[IDMAP_NAMESZ];
10741076 	char owner_group[IDMAP_NAMESZ];
10751077 	int owner_namelen = 0;
....@@ -1158,16 +1160,14 @@
11581160 	if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
11591161 		if (iap->ia_valid & ATTR_ATIME_SET) {
11601162 			*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
1161
-			ts = timespec64_to_timespec(iap->ia_atime);
1162
-			p = xdr_encode_nfstime4(p, &ts);
1163
+			p = xdr_encode_nfstime4(p, &iap->ia_atime);
11631164 		} else
11641165 			*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
11651166 	}
11661167 	if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
11671168 		if (iap->ia_valid & ATTR_MTIME_SET) {
11681169 			*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
1169
-			ts = timespec64_to_timespec(iap->ia_mtime);
1170
-			p = xdr_encode_nfstime4(p, &ts);
1170
+			p = xdr_encode_nfstime4(p, &iap->ia_mtime);
11711171 		} else
11721172 			*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
11731173 	}
....@@ -2340,9 +2340,9 @@
23402340 	encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
23412341 	if (args->lg_args) {
23422342 		encode_layoutget(xdr, args->lg_args, &hdr);
2343
-		xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2,
2344
-				 args->lg_args->layout.pages,
2345
-				 0, args->lg_args->layout.pglen);
2343
+		rpc_prepare_reply_pages(req, args->lg_args->layout.pages, 0,
2344
+					args->lg_args->layout.pglen,
2345
+					hdr.replen);
23462346 	}
23472347 	encode_nops(&hdr);
23482348 }
....@@ -2386,9 +2386,9 @@
23862386 	encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
23872387 	if (args->lg_args) {
23882388 		encode_layoutget(xdr, args->lg_args, &hdr);
2389
-		xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2,
2390
-				 args->lg_args->layout.pages,
2391
-				 0, args->lg_args->layout.pglen);
2389
+		rpc_prepare_reply_pages(req, args->lg_args->layout.pages, 0,
2390
+					args->lg_args->layout.pglen,
2391
+					hdr.replen);
23922392 	}
23932393 	encode_nops(&hdr);
23942394 }
....@@ -2498,8 +2498,8 @@
24982498 	encode_putfh(xdr, args->fh, &hdr);
24992499 	encode_readlink(xdr, args, req, &hdr);
25002500 
2501
-	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2, args->pages,
2502
-			args->pgbase, args->pglen);
2501
+	rpc_prepare_reply_pages(req, args->pages, args->pgbase,
2502
+				args->pglen, hdr.replen);
25032503 	encode_nops(&hdr);
25042504 }
25052505 
....@@ -2519,11 +2519,8 @@
25192519 	encode_putfh(xdr, args->fh, &hdr);
25202520 	encode_readdir(xdr, args, req, &hdr);
25212521 
2522
-	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2, args->pages,
2523
-			 args->pgbase, args->count);
2524
-	dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
2525
-			__func__, hdr.replen << 2, args->pages,
2526
-			args->pgbase, args->count);
2522
+	rpc_prepare_reply_pages(req, args->pages, args->pgbase,
2523
+				args->count, hdr.replen);
25272524 	encode_nops(&hdr);
25282525 }
25292526 
....@@ -2543,8 +2540,8 @@
25432540 	encode_putfh(xdr, args->fh, &hdr);
25442541 	encode_read(xdr, args, &hdr);
25452542 
2546
-	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2,
2547
-			 args->pages, args->pgbase, args->count);
2543
+	rpc_prepare_reply_pages(req, args->pages, args->pgbase,
2544
+				args->count, hdr.replen);
25482545 	req->rq_rcv_buf.flags |= XDRBUF_READ;
25492546 	encode_nops(&hdr);
25502547 }
....@@ -2590,9 +2587,8 @@
25902587 	encode_getattr(xdr, nfs4_acl_bitmap, NULL,
25912588 			ARRAY_SIZE(nfs4_acl_bitmap), &hdr);
25922589 
2593
-	xdr_inline_pages(&req->rq_rcv_buf, replen << 2,
2594
-		args->acl_pages, 0, args->acl_len);
2595
-
2590
+	rpc_prepare_reply_pages(req, args->acl_pages, 0,
2591
+				args->acl_len, replen + 1);
25962592 	encode_nops(&hdr);
25972593 }
25982594 
....@@ -2813,9 +2809,8 @@
28132809 		encode_fs_locations(xdr, args->bitmask, &hdr);
28142810 	}
28152811 
2816
-	/* Set up reply kvec to capture returned fs_locations array. */
2817
-	xdr_inline_pages(&req->rq_rcv_buf, replen << 2,
2818
-			 (struct page **)&args->page, 0, PAGE_SIZE);
2812
+	rpc_prepare_reply_pages(req, (struct page **)&args->page, 0,
2813
+				PAGE_SIZE, replen + 1);
28192814 	encode_nops(&hdr);
28202815 }
28212816 
....@@ -2961,6 +2956,8 @@
29612956 	encode_nops(&hdr);
29622957 }
29632958 
2959
+#endif
2960
+
29642961 /*
29652962  * a GET_LEASE_TIME request
29662963  */
....@@ -2980,6 +2977,8 @@
29802977 	encode_fsinfo(xdr, lease_bitmap, &hdr);
29812978 	encode_nops(&hdr);
29822979 }
2980
+
2981
+#ifdef CONFIG_NFS_V4_1
29832982 
29842983 /*
29852984  * a RECLAIM_COMPLETE request
....@@ -3010,17 +3009,19 @@
30103009 	struct compound_hdr hdr = {
30113010 		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
30123011 	};
3012
+	uint32_t replen;
30133013 
30143014 	encode_compound_hdr(xdr, req, &hdr);
30153015 	encode_sequence(xdr, &args->seq_args, &hdr);
3016
+
3017
+	replen = hdr.replen + op_decode_hdr_maxsz;
3018
+
30163019 	encode_getdeviceinfo(xdr, args, &hdr);
30173020 
3018
-	/* set up reply kvec. Subtract notification bitmap max size (2)
3019
-	 * so that notification bitmap is put in xdr_buf tail */
3020
-	xdr_inline_pages(&req->rq_rcv_buf, (hdr.replen - 2) << 2,
3021
-			 args->pdev->pages, args->pdev->pgbase,
3022
-			 args->pdev->pglen);
3023
-
3021
+	/* set up reply kvec. device_addr4 opaque data is read into the
3022
+	 * pages */
3023
+	rpc_prepare_reply_pages(req, args->pdev->pages, args->pdev->pgbase,
3024
+				args->pdev->pglen, replen + 2 + 1);
30243025 	encode_nops(&hdr);
30253026 }
30263027 
....@@ -3041,9 +3042,8 @@
30413042 	encode_putfh(xdr, NFS_FH(args->inode), &hdr);
30423043 	encode_layoutget(xdr, args, &hdr);
30433044 
3044
-	xdr_inline_pages(&req->rq_rcv_buf, hdr.replen << 2,
3045
-	    args->layout.pages, 0, args->layout.pglen);
3046
-
3045
+	rpc_prepare_reply_pages(req, args->layout.pages, 0,
3046
+				args->layout.pglen, hdr.replen);
30473047 	encode_nops(&hdr);
30483048 }
30493049 
....@@ -3144,22 +3144,12 @@
31443144 }
31453145 #endif /* CONFIG_NFS_V4_1 */
31463146 
3147
-static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
3148
-{
3149
-	dprintk("nfs: %s: prematurely hit end of receive buffer. "
3150
-		"Remaining buffer length is %tu words.\n",
3151
-		func, xdr->end - xdr->p);
3152
-}
3153
-
31543147 static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string)
31553148 {
31563149 	ssize_t ret = xdr_stream_decode_opaque_inline(xdr, (void **)string,
31573150 			NFS4_OPAQUE_LIMIT);
3158
-	if (unlikely(ret < 0)) {
3159
-		if (ret == -EBADMSG)
3160
-			print_overflow_msg(__func__, xdr);
3151
+	if (unlikely(ret < 0))
31613152 		return -EIO;
3162
-	}
31633153 	*len = ret;
31643154 	return 0;
31653155 }
....@@ -3170,22 +3160,19 @@
31703160 
31713161 	p = xdr_inline_decode(xdr, 8);
31723162 	if (unlikely(!p))
3173
-		goto out_overflow;
3163
+		return -EIO;
31743164 	hdr->status = be32_to_cpup(p++);
31753165 	hdr->taglen = be32_to_cpup(p);
31763166 
31773167 	p = xdr_inline_decode(xdr, hdr->taglen + 4);
31783168 	if (unlikely(!p))
3179
-		goto out_overflow;
3169
+		return -EIO;
31803170 	hdr->tag = (char *)p;
31813171 	p += XDR_QUADLEN(hdr->taglen);
31823172 	hdr->nops = be32_to_cpup(p);
31833173 	if (unlikely(hdr->nops < 1))
31843174 		return nfs4_stat_to_errno(hdr->status);
31853175 	return 0;
3186
-out_overflow:
3187
-	print_overflow_msg(__func__, xdr);
3188
-	return -EIO;
31893176 }
31903177 
31913178 static bool __decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected,
....@@ -3201,11 +3188,14 @@
32013188 	opnum = be32_to_cpup(p++);
32023189 	if (unlikely(opnum != expected))
32033190 		goto out_bad_operation;
3191
+	if (unlikely(*p != cpu_to_be32(NFS_OK)))
3192
+		goto out_status;
3193
+	*nfs_retval = 0;
3194
+	return true;
3195
+out_status:
32043196 	nfserr = be32_to_cpup(p);
3205
-	if (nfserr == NFS_OK)
3206
-		*nfs_retval = 0;
3207
-	else
3208
-		*nfs_retval = nfs4_stat_to_errno(nfserr);
3197
+	trace_nfs4_xdr_status(xdr, opnum, nfserr);
3198
+	*nfs_retval = nfs4_stat_to_errno(nfserr);
32093199 	return true;
32103200 out_bad_operation:
32113201 	dprintk("nfs: Server returned operation"
....@@ -3214,7 +3204,6 @@
32143204 	*nfs_retval = -EREMOTEIO;
32153205 	return false;
32163206 out_overflow:
3217
-	print_overflow_msg(__func__, xdr);
32183207 	*nfs_retval = -EIO;
32193208 	return false;
32203209 }
....@@ -3235,10 +3224,9 @@
32353224 	char *str;
32363225 
32373226 	p = xdr_inline_decode(xdr, 12);
3238
-	if (likely(p))
3239
-		return decode_opaque_inline(xdr, &strlen, &str);
3240
-	print_overflow_msg(__func__, xdr);
3241
-	return -EIO;
3227
+	if (unlikely(!p))
3228
+		return -EIO;
3229
+	return decode_opaque_inline(xdr, &strlen, &str);
32423230 }
32433231 
32443232 static ssize_t
....@@ -3249,10 +3237,9 @@
32493237 	ret = xdr_stream_decode_uint32_array(xdr, bitmap, sz);
32503238 	if (likely(ret >= 0))
32513239 		return ret;
3252
-	if (ret == -EMSGSIZE)
3253
-		return sz;
3254
-	print_overflow_msg(__func__, xdr);
3255
-	return -EIO;
3240
+	if (ret != -EMSGSIZE)
3241
+		return -EIO;
3242
+	return sz;
32563243 }
32573244 
32583245 static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
....@@ -3268,13 +3255,10 @@
32683255 
32693256 	p = xdr_inline_decode(xdr, 4);
32703257 	if (unlikely(!p))
3271
-		goto out_overflow;
3258
+		return -EIO;
32723259 	*attrlen = be32_to_cpup(p);
32733260 	*savep = xdr_stream_pos(xdr);
32743261 	return 0;
3275
-out_overflow:
3276
-	print_overflow_msg(__func__, xdr);
3277
-	return -EIO;
32783262 }
32793263 
32803264 static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
....@@ -3303,7 +3287,7 @@
33033287 	if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
33043288 		p = xdr_inline_decode(xdr, 4);
33053289 		if (unlikely(!p))
3306
-			goto out_overflow;
3290
+			return -EIO;
33073291 		*type = be32_to_cpup(p);
33083292 		if (*type < NF4REG || *type > NF4NAMEDATTR) {
33093293 			dprintk("%s: bad type %d\n", __func__, *type);
....@@ -3314,9 +3298,6 @@
33143298 	}
33153299 	dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]);
33163300 	return ret;
3317
-out_overflow:
3318
-	print_overflow_msg(__func__, xdr);
3319
-	return -EIO;
33203301 }
33213302 
33223303 static int decode_attr_fh_expire_type(struct xdr_stream *xdr,
....@@ -3330,15 +3311,12 @@
33303311 	if (likely(bitmap[0] & FATTR4_WORD0_FH_EXPIRE_TYPE)) {
33313312 		p = xdr_inline_decode(xdr, 4);
33323313 		if (unlikely(!p))
3333
-			goto out_overflow;
3314
+			return -EIO;
33343315 		*type = be32_to_cpup(p);
33353316 		bitmap[0] &= ~FATTR4_WORD0_FH_EXPIRE_TYPE;
33363317 	}
33373318 	dprintk("%s: expire type=0x%x\n", __func__, *type);
33383319 	return 0;
3339
-out_overflow:
3340
-	print_overflow_msg(__func__, xdr);
3341
-	return -EIO;
33423320 }
33433321 
33443322 static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
....@@ -3352,7 +3330,7 @@
33523330 	if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
33533331 		p = xdr_inline_decode(xdr, 8);
33543332 		if (unlikely(!p))
3355
-			goto out_overflow;
3333
+			return -EIO;
33563334 		xdr_decode_hyper(p, change);
33573335 		bitmap[0] &= ~FATTR4_WORD0_CHANGE;
33583336 		ret = NFS_ATTR_FATTR_CHANGE;
....@@ -3360,9 +3338,6 @@
33603338 	dprintk("%s: change attribute=%Lu\n", __func__,
33613339 			(unsigned long long)*change);
33623340 	return ret;
3363
-out_overflow:
3364
-	print_overflow_msg(__func__, xdr);
3365
-	return -EIO;
33663341 }
33673342 
33683343 static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
....@@ -3376,16 +3351,13 @@
33763351 	if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
33773352 		p = xdr_inline_decode(xdr, 8);
33783353 		if (unlikely(!p))
3379
-			goto out_overflow;
3354
+			return -EIO;
33803355 		xdr_decode_hyper(p, size);
33813356 		bitmap[0] &= ~FATTR4_WORD0_SIZE;
33823357 		ret = NFS_ATTR_FATTR_SIZE;
33833358 	}
33843359 	dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
33853360 	return ret;
3386
-out_overflow:
3387
-	print_overflow_msg(__func__, xdr);
3388
-	return -EIO;
33893361 }
33903362 
33913363 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
....@@ -3398,15 +3370,12 @@
33983370 	if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
33993371 		p = xdr_inline_decode(xdr, 4);
34003372 		if (unlikely(!p))
3401
-			goto out_overflow;
3373
+			return -EIO;
34023374 		*res = be32_to_cpup(p);
34033375 		bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
34043376 	}
34053377 	dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
34063378 	return 0;
3407
-out_overflow:
3408
-	print_overflow_msg(__func__, xdr);
3409
-	return -EIO;
34103379 }
34113380 
34123381 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
....@@ -3419,15 +3388,12 @@
34193388 	if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
34203389 		p = xdr_inline_decode(xdr, 4);
34213390 		if (unlikely(!p))
3422
-			goto out_overflow;
3391
+			return -EIO;
34233392 		*res = be32_to_cpup(p);
34243393 		bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
34253394 	}
34263395 	dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
34273396 	return 0;
3428
-out_overflow:
3429
-	print_overflow_msg(__func__, xdr);
3430
-	return -EIO;
34313397 }
34323398 
34333399 static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)
....@@ -3442,7 +3408,7 @@
34423408 	if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
34433409 		p = xdr_inline_decode(xdr, 16);
34443410 		if (unlikely(!p))
3445
-			goto out_overflow;
3411
+			return -EIO;
34463412 		p = xdr_decode_hyper(p, &fsid->major);
34473413 		xdr_decode_hyper(p, &fsid->minor);
34483414 		bitmap[0] &= ~FATTR4_WORD0_FSID;
....@@ -3452,9 +3418,6 @@
34523418 			(unsigned long long)fsid->major,
34533419 			(unsigned long long)fsid->minor);
34543420 	return ret;
3455
-out_overflow:
3456
-	print_overflow_msg(__func__, xdr);
3457
-	return -EIO;
34583421 }
34593422 
34603423 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
....@@ -3467,15 +3430,12 @@
34673430 	if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
34683431 		p = xdr_inline_decode(xdr, 4);
34693432 		if (unlikely(!p))
3470
-			goto out_overflow;
3433
+			return -EIO;
34713434 		*res = be32_to_cpup(p);
34723435 		bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
34733436 	}
3474
-	dprintk("%s: file size=%u\n", __func__, (unsigned int)*res);
3437
+	dprintk("%s: lease time=%u\n", __func__, (unsigned int)*res);
34753438 	return 0;
3476
-out_overflow:
3477
-	print_overflow_msg(__func__, xdr);
3478
-	return -EIO;
34793439 }
34803440 
34813441 static int decode_attr_error(struct xdr_stream *xdr, uint32_t *bitmap, int32_t *res)
....@@ -3487,14 +3447,11 @@
34873447 	if (likely(bitmap[0] & FATTR4_WORD0_RDATTR_ERROR)) {
34883448 		p = xdr_inline_decode(xdr, 4);
34893449 		if (unlikely(!p))
3490
-			goto out_overflow;
3450
+			return -EIO;
34913451 		bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
34923452 		*res = -be32_to_cpup(p);
34933453 	}
34943454 	return 0;
3495
-out_overflow:
3496
-	print_overflow_msg(__func__, xdr);
3497
-	return -EIO;
34983455 }
34993456 
35003457 static int decode_attr_exclcreat_supported(struct xdr_stream *xdr,
....@@ -3516,7 +3473,7 @@
35163473 static int decode_attr_filehandle(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fh *fh)
35173474 {
35183475 	__be32 *p;
3519
-	int len;
3476
+	u32 len;
35203477 
35213478 	if (fh != NULL)
35223479 		memset(fh, 0, sizeof(*fh));
....@@ -3526,13 +3483,13 @@
35263483 	if (likely(bitmap[0] & FATTR4_WORD0_FILEHANDLE)) {
35273484 		p = xdr_inline_decode(xdr, 4);
35283485 		if (unlikely(!p))
3529
-			goto out_overflow;
3486
+			return -EIO;
35303487 		len = be32_to_cpup(p);
35313488 		if (len > NFS4_FHSIZE)
35323489 			return -EIO;
35333490 		p = xdr_inline_decode(xdr, len);
35343491 		if (unlikely(!p))
3535
-			goto out_overflow;
3492
+			return -EIO;
35363493 		if (fh != NULL) {
35373494 			memcpy(fh->data, p, len);
35383495 			fh->size = len;
....@@ -3540,9 +3497,6 @@
35403497 		bitmap[0] &= ~FATTR4_WORD0_FILEHANDLE;
35413498 	}
35423499 	return 0;
3543
-out_overflow:
3544
-	print_overflow_msg(__func__, xdr);
3545
-	return -EIO;
35463500 }
35473501 
35483502 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
....@@ -3555,15 +3509,12 @@
35553509 	if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
35563510 		p = xdr_inline_decode(xdr, 4);
35573511 		if (unlikely(!p))
3558
-			goto out_overflow;
3512
+			return -EIO;
35593513 		*res = be32_to_cpup(p);
35603514 		bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
35613515 	}
35623516 	dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
35633517 	return 0;
3564
-out_overflow:
3565
-	print_overflow_msg(__func__, xdr);
3566
-	return -EIO;
35673518 }
35683519 
35693520 static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
....@@ -3577,16 +3528,13 @@
35773528 	if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
35783529 		p = xdr_inline_decode(xdr, 8);
35793530 		if (unlikely(!p))
3580
-			goto out_overflow;
3531
+			return -EIO;
35813532 		xdr_decode_hyper(p, fileid);
35823533 		bitmap[0] &= ~FATTR4_WORD0_FILEID;
35833534 		ret = NFS_ATTR_FATTR_FILEID;
35843535 	}
35853536 	dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
35863537 	return ret;
3587
-out_overflow:
3588
-	print_overflow_msg(__func__, xdr);
3589
-	return -EIO;
35903538 }
35913539 
35923540 static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
....@@ -3600,16 +3548,13 @@
36003548 	if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {
36013549 		p = xdr_inline_decode(xdr, 8);
36023550 		if (unlikely(!p))
3603
-			goto out_overflow;
3551
+			return -EIO;
36043552 		xdr_decode_hyper(p, fileid);
36053553 		bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
36063554 		ret = NFS_ATTR_FATTR_MOUNTED_ON_FILEID;
36073555 	}
36083556 	dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
36093557 	return ret;
3610
-out_overflow:
3611
-	print_overflow_msg(__func__, xdr);
3612
-	return -EIO;
36133558 }
36143559 
36153560 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
....@@ -3623,15 +3568,12 @@
36233568 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
36243569 		p = xdr_inline_decode(xdr, 8);
36253570 		if (unlikely(!p))
3626
-			goto out_overflow;
3571
+			return -EIO;
36273572 		xdr_decode_hyper(p, res);
36283573 		bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
36293574 	}
36303575 	dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
36313576 	return status;
3632
-out_overflow:
3633
-	print_overflow_msg(__func__, xdr);
3634
-	return -EIO;
36353577 }
36363578 
36373579 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
....@@ -3645,15 +3587,12 @@
36453587 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
36463588 		p = xdr_inline_decode(xdr, 8);
36473589 		if (unlikely(!p))
3648
-			goto out_overflow;
3590
+			return -EIO;
36493591 		xdr_decode_hyper(p, res);
36503592 		bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
36513593 	}
36523594 	dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
36533595 	return status;
3654
-out_overflow:
3655
-	print_overflow_msg(__func__, xdr);
3656
-	return -EIO;
36573596 }
36583597 
36593598 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
....@@ -3667,15 +3606,12 @@
36673606 	if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
36683607 		p = xdr_inline_decode(xdr, 8);
36693608 		if (unlikely(!p))
3670
-			goto out_overflow;
3609
+			return -EIO;
36713610 		xdr_decode_hyper(p, res);
36723611 		bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
36733612 	}
36743613 	dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
36753614 	return status;
3676
-out_overflow:
3677
-	print_overflow_msg(__func__, xdr);
3678
-	return -EIO;
36793615 }
36803616 
36813617 static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path)
....@@ -3686,7 +3622,7 @@
36863622 
36873623 	p = xdr_inline_decode(xdr, 4);
36883624 	if (unlikely(!p))
3689
-		goto out_overflow;
3625
+		return -EIO;
36903626 	n = be32_to_cpup(p);
36913627 	if (n == 0)
36923628 		goto root_path;
....@@ -3718,9 +3654,6 @@
37183654 	dprintk(" status %d", status);
37193655 	status = -EIO;
37203656 	goto out;
3721
-out_overflow:
3722
-	print_overflow_msg(__func__, xdr);
3723
-	return -EIO;
37243657 }
37253658 
37263659 static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
....@@ -3745,7 +3678,7 @@
37453678 		goto out;
37463679 	p = xdr_inline_decode(xdr, 4);
37473680 	if (unlikely(!p))
3748
-		goto out_overflow;
3681
+		goto out_eio;
37493682 	n = be32_to_cpup(p);
37503683 	for (res->nlocations = 0; res->nlocations < n; res->nlocations++) {
37513684 		u32 m;
....@@ -3756,7 +3689,7 @@
37563689 		loc = &res->locations[res->nlocations];
37573690 		p = xdr_inline_decode(xdr, 4);
37583691 		if (unlikely(!p))
3759
-			goto out_overflow;
3692
+			goto out_eio;
37603693 		m = be32_to_cpup(p);
37613694 
37623695 		dprintk("%s: servers:\n", __func__);
....@@ -3794,8 +3727,6 @@
37943727 out:
37953728 	dprintk("%s: fs_locations done, error = %d\n", __func__, status);
37963729 	return status;
3797
-out_overflow:
3798
-	print_overflow_msg(__func__, xdr);
37993730 out_eio:
38003731 	status = -EIO;
38013732 	goto out;
....@@ -3812,15 +3743,12 @@
38123743 	if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
38133744 		p = xdr_inline_decode(xdr, 8);
38143745 		if (unlikely(!p))
3815
-			goto out_overflow;
3746
+			return -EIO;
38163747 		xdr_decode_hyper(p, res);
38173748 		bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
38183749 	}
38193750 	dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
38203751 	return status;
3821
-out_overflow:
3822
-	print_overflow_msg(__func__, xdr);
3823
-	return -EIO;
38243752 }
38253753 
38263754 static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
....@@ -3834,15 +3762,12 @@
38343762 	if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
38353763 		p = xdr_inline_decode(xdr, 4);
38363764 		if (unlikely(!p))
3837
-			goto out_overflow;
3765
+			return -EIO;
38383766 		*maxlink = be32_to_cpup(p);
38393767 		bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
38403768 	}
38413769 	dprintk("%s: maxlink=%u\n", __func__, *maxlink);
38423770 	return status;
3843
-out_overflow:
3844
-	print_overflow_msg(__func__, xdr);
3845
-	return -EIO;
38463771 }
38473772 
38483773 static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
....@@ -3856,15 +3781,12 @@
38563781 	if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
38573782 		p = xdr_inline_decode(xdr, 4);
38583783 		if (unlikely(!p))
3859
-			goto out_overflow;
3784
+			return -EIO;
38603785 		*maxname = be32_to_cpup(p);
38613786 		bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
38623787 	}
38633788 	dprintk("%s: maxname=%u\n", __func__, *maxname);
38643789 	return status;
3865
-out_overflow:
3866
-	print_overflow_msg(__func__, xdr);
3867
-	return -EIO;
38683790 }
38693791 
38703792 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
....@@ -3879,7 +3801,7 @@
38793801 		uint64_t maxread;
38803802 		p = xdr_inline_decode(xdr, 8);
38813803 		if (unlikely(!p))
3882
-			goto out_overflow;
3804
+			return -EIO;
38833805 		xdr_decode_hyper(p, &maxread);
38843806 		if (maxread > 0x7FFFFFFF)
38853807 			maxread = 0x7FFFFFFF;
....@@ -3888,9 +3810,6 @@
38883810 	}
38893811 	dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
38903812 	return status;
3891
-out_overflow:
3892
-	print_overflow_msg(__func__, xdr);
3893
-	return -EIO;
38943813 }
38953814 
38963815 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
....@@ -3905,7 +3824,7 @@
39053824 		uint64_t maxwrite;
39063825 		p = xdr_inline_decode(xdr, 8);
39073826 		if (unlikely(!p))
3908
-			goto out_overflow;
3827
+			return -EIO;
39093828 		xdr_decode_hyper(p, &maxwrite);
39103829 		if (maxwrite > 0x7FFFFFFF)
39113830 			maxwrite = 0x7FFFFFFF;
....@@ -3914,9 +3833,6 @@
39143833 	}
39153834 	dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
39163835 	return status;
3917
-out_overflow:
3918
-	print_overflow_msg(__func__, xdr);
3919
-	return -EIO;
39203836 }
39213837 
39223838 static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode)
....@@ -3931,7 +3847,7 @@
39313847 	if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
39323848 		p = xdr_inline_decode(xdr, 4);
39333849 		if (unlikely(!p))
3934
-			goto out_overflow;
3850
+			return -EIO;
39353851 		tmp = be32_to_cpup(p);
39363852 		*mode = tmp & ~S_IFMT;
39373853 		bitmap[1] &= ~FATTR4_WORD1_MODE;
....@@ -3939,9 +3855,6 @@
39393855 	}
39403856 	dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
39413857 	return ret;
3942
-out_overflow:
3943
-	print_overflow_msg(__func__, xdr);
3944
-	return -EIO;
39453858 }
39463859 
39473860 static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
....@@ -3955,16 +3868,13 @@
39553868 	if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
39563869 		p = xdr_inline_decode(xdr, 4);
39573870 		if (unlikely(!p))
3958
-			goto out_overflow;
3871
+			return -EIO;
39593872 		*nlink = be32_to_cpup(p);
39603873 		bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
39613874 		ret = NFS_ATTR_FATTR_NLINK;
39623875 	}
39633876 	dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
39643877 	return ret;
3965
-out_overflow:
3966
-	print_overflow_msg(__func__, xdr);
3967
-	return -EIO;
39683878 }
39693879 
39703880 static ssize_t decode_nfs4_string(struct xdr_stream *xdr,
....@@ -4009,10 +3919,9 @@
40093919 		return NFS_ATTR_FATTR_OWNER;
40103920 	}
40113921 out:
4012
-	if (len != -EBADMSG)
4013
-		return 0;
4014
-	print_overflow_msg(__func__, xdr);
4015
-	return -EIO;
3922
+	if (len == -EBADMSG)
3923
+		return -EIO;
3924
+	return 0;
40163925 }
40173926 
40183927 static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap,
....@@ -4044,10 +3953,9 @@
40443953 		return NFS_ATTR_FATTR_GROUP;
40453954 	}
40463955 out:
4047
-	if (len != -EBADMSG)
4048
-		return 0;
4049
-	print_overflow_msg(__func__, xdr);
4050
-	return -EIO;
3956
+	if (len == -EBADMSG)
3957
+		return -EIO;
3958
+	return 0;
40513959 }
40523960 
40533961 static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
....@@ -4064,7 +3972,7 @@
40643972 
40653973 		p = xdr_inline_decode(xdr, 8);
40663974 		if (unlikely(!p))
4067
-			goto out_overflow;
3975
+			return -EIO;
40683976 		major = be32_to_cpup(p++);
40693977 		minor = be32_to_cpup(p);
40703978 		tmp = MKDEV(major, minor);
....@@ -4075,9 +3983,6 @@
40753983 	}
40763984 	dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
40773985 	return ret;
4078
-out_overflow:
4079
-	print_overflow_msg(__func__, xdr);
4080
-	return -EIO;
40813986 }
40823987 
40833988 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
....@@ -4091,15 +3996,12 @@
40913996 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
40923997 		p = xdr_inline_decode(xdr, 8);
40933998 		if (unlikely(!p))
4094
-			goto out_overflow;
3999
+			return -EIO;
40954000 		xdr_decode_hyper(p, res);
40964001 		bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
40974002 	}
40984003 	dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
40994004 	return status;
4100
-out_overflow:
4101
-	print_overflow_msg(__func__, xdr);
4102
-	return -EIO;
41034005 }
41044006 
41054007 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
....@@ -4113,15 +4015,12 @@
41134015 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
41144016 		p = xdr_inline_decode(xdr, 8);
41154017 		if (unlikely(!p))
4116
-			goto out_overflow;
4018
+			return -EIO;
41174019 		xdr_decode_hyper(p, res);
41184020 		bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
41194021 	}
41204022 	dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
41214023 	return status;
4122
-out_overflow:
4123
-	print_overflow_msg(__func__, xdr);
4124
-	return -EIO;
41254024 }
41264025 
41274026 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
....@@ -4135,15 +4034,12 @@
41354034 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
41364035 		p = xdr_inline_decode(xdr, 8);
41374036 		if (unlikely(!p))
4138
-			goto out_overflow;
4037
+			return -EIO;
41394038 		xdr_decode_hyper(p, res);
41404039 		bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
41414040 	}
41424041 	dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
41434042 	return status;
4144
-out_overflow:
4145
-	print_overflow_msg(__func__, xdr);
4146
-	return -EIO;
41474043 }
41484044 
41494045 static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
....@@ -4157,7 +4053,7 @@
41574053 	if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
41584054 		p = xdr_inline_decode(xdr, 8);
41594055 		if (unlikely(!p))
4160
-			goto out_overflow;
4056
+			return -EIO;
41614057 		xdr_decode_hyper(p, used);
41624058 		bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
41634059 		ret = NFS_ATTR_FATTR_SPACE_USED;
....@@ -4165,37 +4061,31 @@
41654061 	dprintk("%s: space used=%Lu\n", __func__,
41664062 			(unsigned long long)*used);
41674063 	return ret;
4168
-out_overflow:
4169
-	print_overflow_msg(__func__, xdr);
4170
-	return -EIO;
41714064 }
41724065 
41734066 static __be32 *
4174
-xdr_decode_nfstime4(__be32 *p, struct timespec *t)
4067
+xdr_decode_nfstime4(__be32 *p, struct timespec64 *t)
41754068 {
41764069 	__u64 sec;
41774070 
41784071 	p = xdr_decode_hyper(p, &sec);
4179
-	t-> tv_sec = (time_t)sec;
4072
+	t-> tv_sec = sec;
41804073 	t->tv_nsec = be32_to_cpup(p++);
41814074 	return p;
41824075 }
41834076 
4184
-static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time)
4077
+static int decode_attr_time(struct xdr_stream *xdr, struct timespec64 *time)
41854078 {
41864079 	__be32 *p;
41874080 
41884081 	p = xdr_inline_decode(xdr, nfstime4_maxsz << 2);
41894082 	if (unlikely(!p))
4190
-		goto out_overflow;
4083
+		return -EIO;
41914084 	xdr_decode_nfstime4(p, time);
41924085 	return 0;
4193
-out_overflow:
4194
-	print_overflow_msg(__func__, xdr);
4195
-	return -EIO;
41964086 }
41974087 
4198
-static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
4088
+static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)
41994089 {
42004090 	int status = 0;
42014091 
....@@ -4209,11 +4099,11 @@
42094099 			status = NFS_ATTR_FATTR_ATIME;
42104100 		bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
42114101 	}
4212
-	dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
4102
+	dprintk("%s: atime=%lld\n", __func__, time->tv_sec);
42134103 	return status;
42144104 }
42154105 
4216
-static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
4106
+static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)
42174107 {
42184108 	int status = 0;
42194109 
....@@ -4227,12 +4117,12 @@
42274117 			status = NFS_ATTR_FATTR_CTIME;
42284118 		bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
42294119 	}
4230
-	dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
4120
+	dprintk("%s: ctime=%lld\n", __func__, time->tv_sec);
42314121 	return status;
42324122 }
42334123 
42344124 static int decode_attr_time_delta(struct xdr_stream *xdr, uint32_t *bitmap,
4235
-				  struct timespec *time)
4125
+				  struct timespec64 *time)
42364126 {
42374127 	int status = 0;
42384128 
....@@ -4244,8 +4134,8 @@
42444134 		status = decode_attr_time(xdr, time);
42454135 		bitmap[1] &= ~FATTR4_WORD1_TIME_DELTA;
42464136 	}
4247
-	dprintk("%s: time_delta=%ld %ld\n", __func__, (long)time->tv_sec,
4248
-		(long)time->tv_nsec);
4137
+	dprintk("%s: time_delta=%lld %ld\n", __func__, time->tv_sec,
4138
+		time->tv_nsec);
42494139 	return status;
42504140 }
42514141 
....@@ -4263,32 +4153,30 @@
42634153 	if (likely(bitmap[2] & FATTR4_WORD2_SECURITY_LABEL)) {
42644154 		p = xdr_inline_decode(xdr, 4);
42654155 		if (unlikely(!p))
4266
-			goto out_overflow;
4156
+			return -EIO;
42674157 		lfs = be32_to_cpup(p++);
42684158 		p = xdr_inline_decode(xdr, 4);
42694159 		if (unlikely(!p))
4270
-			goto out_overflow;
4160
+			return -EIO;
42714161 		pi = be32_to_cpup(p++);
42724162 		p = xdr_inline_decode(xdr, 4);
42734163 		if (unlikely(!p))
4274
-			goto out_overflow;
4164
+			return -EIO;
42754165 		len = be32_to_cpup(p++);
42764166 		p = xdr_inline_decode(xdr, len);
42774167 		if (unlikely(!p))
4278
-			goto out_overflow;
4168
+			return -EIO;
4169
+		bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
42794170 		if (len < NFS4_MAXLABELLEN) {
4280
-			if (label) {
4281
-				if (label->len) {
4282
-					if (label->len < len)
4283
-						return -ERANGE;
4284
-					memcpy(label->label, p, len);
4285
-				}
4171
+			if (label && label->len) {
4172
+				if (label->len < len)
4173
+					return -ERANGE;
4174
+				memcpy(label->label, p, len);
42864175 				label->len = len;
42874176 				label->pi = pi;
42884177 				label->lfs = lfs;
42894178 				status = NFS_ATTR_FATTR_V4_SECURITY_LABEL;
42904179 			}
4291
-			bitmap[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
42924180 		} else
42934181 			printk(KERN_WARNING "%s: label too long (%u)!\n",
42944182 					__func__, len);
....@@ -4298,13 +4186,9 @@
42984186 				label->len, label->pi, label->lfs);
42994187 	}
43004188 	return status;
4301
-
4302
-out_overflow:
4303
-	print_overflow_msg(__func__, xdr);
4304
-	return -EIO;
43054189 }
43064190 
4307
-static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
4191
+static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec64 *time)
43084192 {
43094193 	int status = 0;
43104194 
....@@ -4318,8 +4202,28 @@
43184202 			status = NFS_ATTR_FATTR_MTIME;
43194203 		bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
43204204 	}
4321
-	dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
4205
+	dprintk("%s: mtime=%lld\n", __func__, time->tv_sec);
43224206 	return status;
4207
+}
4208
+
4209
+static int decode_attr_xattrsupport(struct xdr_stream *xdr, uint32_t *bitmap,
4210
+				    uint32_t *res)
4211
+{
4212
+	__be32 *p;
4213
+
4214
+	*res = 0;
4215
+	if (unlikely(bitmap[2] & (FATTR4_WORD2_XATTR_SUPPORT - 1U)))
4216
+		return -EIO;
4217
+	if (likely(bitmap[2] & FATTR4_WORD2_XATTR_SUPPORT)) {
4218
+		p = xdr_inline_decode(xdr, 4);
4219
+		if (unlikely(!p))
4220
+			return -EIO;
4221
+		*res = be32_to_cpup(p);
4222
+		bitmap[2] &= ~FATTR4_WORD2_XATTR_SUPPORT;
4223
+	}
4224
+	dprintk("%s: XATTR support=%s\n", __func__,
4225
+		*res == 0 ? "false" : "true");
4226
+	return 0;
43234227 }
43244228 
43254229 static int verify_attr_len(struct xdr_stream *xdr, unsigned int savep, uint32_t attrlen)
....@@ -4345,14 +4249,11 @@
43454249 
43464250 	p = xdr_inline_decode(xdr, 20);
43474251 	if (unlikely(!p))
4348
-		goto out_overflow;
4252
+		return -EIO;
43494253 	cinfo->atomic = be32_to_cpup(p++);
43504254 	p = xdr_decode_hyper(p, &cinfo->before);
43514255 	xdr_decode_hyper(p, &cinfo->after);
43524256 	return 0;
4353
-out_overflow:
4354
-	print_overflow_msg(__func__, xdr);
4355
-	return -EIO;
43564257 }
43574258 
43584259 static int decode_access(struct xdr_stream *xdr, u32 *supported, u32 *access)
....@@ -4366,24 +4267,19 @@
43664267 		return status;
43674268 	p = xdr_inline_decode(xdr, 8);
43684269 	if (unlikely(!p))
4369
-		goto out_overflow;
4270
+		return -EIO;
43704271 	supp = be32_to_cpup(p++);
43714272 	acc = be32_to_cpup(p);
43724273 	*supported = supp;
43734274 	*access = acc;
43744275 	return 0;
4375
-out_overflow:
4376
-	print_overflow_msg(__func__, xdr);
4377
-	return -EIO;
43784276 }
43794277 
43804278 static int decode_opaque_fixed(struct xdr_stream *xdr, void *buf, size_t len)
43814279 {
43824280 	ssize_t ret = xdr_stream_decode_opaque_fixed(xdr, buf, len);
4383
-	if (unlikely(ret < 0)) {
4384
-		print_overflow_msg(__func__, xdr);
4281
+	if (unlikely(ret < 0))
43854282 		return -EIO;
4386
-	}
43874283 	return 0;
43884284 }
43894285 
....@@ -4466,13 +4362,11 @@
44664362 		return status;
44674363 	p = xdr_inline_decode(xdr, 4);
44684364 	if (unlikely(!p))
4469
-		goto out_overflow;
4365
+		return -EIO;
44704366 	bmlen = be32_to_cpup(p);
44714367 	p = xdr_inline_decode(xdr, bmlen << 2);
44724368 	if (likely(p))
44734369 		return 0;
4474
-out_overflow:
4475
-	print_overflow_msg(__func__, xdr);
44764370 	return -EIO;
44774371 }
44784372 
....@@ -4580,13 +4474,10 @@
45804474 	if (likely(bitmap[0] & hint_bit)) {
45814475 		p = xdr_inline_decode(xdr, 8);
45824476 		if (unlikely(!p))
4583
-			goto out_overflow;
4477
+			return -EIO;
45844478 		xdr_decode_hyper(p, res);
45854479 	}
45864480 	return 0;
4587
-out_overflow:
4588
-	print_overflow_msg(__func__, xdr);
4589
-	return -EIO;
45904481 }
45914482 
45924483 static int decode_first_threshold_item4(struct xdr_stream *xdr,
....@@ -4599,10 +4490,8 @@
45994490 
46004491 	/* layout type */
46014492 	p = xdr_inline_decode(xdr, 4);
4602
-	if (unlikely(!p)) {
4603
-		print_overflow_msg(__func__, xdr);
4493
+	if (unlikely(!p))
46044494 		return -EIO;
4605
-	}
46064495 	res->l_type = be32_to_cpup(p);
46074496 
46084497 	/* thi_hintset bitmap */
....@@ -4660,7 +4549,7 @@
46604549 			return -EREMOTEIO;
46614550 		p = xdr_inline_decode(xdr, 4);
46624551 		if (unlikely(!p))
4663
-			goto out_overflow;
4552
+			return -EIO;
46644553 		num = be32_to_cpup(p);
46654554 		if (num == 0)
46664555 			return 0;
....@@ -4673,9 +4562,6 @@
46734562 		bitmap[2] &= ~FATTR4_WORD2_MDSTHRESHOLD;
46744563 	}
46754564 	return status;
4676
-out_overflow:
4677
-	print_overflow_msg(__func__, xdr);
4678
-	return -EIO;
46794565 }
46804566 
46814567 static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
....@@ -4863,7 +4749,7 @@
48634749 
48644750 	p = xdr_inline_decode(xdr, 4);
48654751 	if (unlikely(!p))
4866
-		goto out_overflow;
4752
+		return -EIO;
48674753 	fsinfo->nlayouttypes = be32_to_cpup(p);
48684754 
48694755 	/* pNFS is not supported by the underlying file system */
....@@ -4873,7 +4759,7 @@
48734759 	/* Decode and set first layout type, move xdr->p past unused types */
48744760 	p = xdr_inline_decode(xdr, fsinfo->nlayouttypes * 4);
48754761 	if (unlikely(!p))
4876
-		goto out_overflow;
4762
+		return -EIO;
48774763 
48784764 	/* If we get too many, then just cap it at the max */
48794765 	if (fsinfo->nlayouttypes > NFS_MAX_LAYOUT_TYPES) {
....@@ -4885,9 +4771,6 @@
48854771 	for(i = 0; i < fsinfo->nlayouttypes; ++i)
48864772 		fsinfo->layouttype[i] = be32_to_cpup(p++);
48874773 	return 0;
4888
-out_overflow:
4889
-	print_overflow_msg(__func__, xdr);
4890
-	return -EIO;
48914774 }
48924775 
48934776 /*
....@@ -4921,10 +4804,8 @@
49214804 	*res = 0;
49224805 	if (bitmap[2] & FATTR4_WORD2_LAYOUT_BLKSIZE) {
49234806 		p = xdr_inline_decode(xdr, 4);
4924
-		if (unlikely(!p)) {
4925
-			print_overflow_msg(__func__, xdr);
4807
+		if (unlikely(!p))
49264808 			return -EIO;
4927
-		}
49284809 		*res = be32_to_cpup(p);
49294810 		bitmap[2] &= ~FATTR4_WORD2_LAYOUT_BLKSIZE;
49304811 	}
....@@ -4943,10 +4824,8 @@
49434824 	*res = 0;
49444825 	if (bitmap[2] & FATTR4_WORD2_CLONE_BLKSIZE) {
49454826 		p = xdr_inline_decode(xdr, 4);
4946
-		if (unlikely(!p)) {
4947
-			print_overflow_msg(__func__, xdr);
4827
+		if (unlikely(!p))
49484828 			return -EIO;
4949
-		}
49504829 		*res = be32_to_cpup(p);
49514830 		bitmap[2] &= ~FATTR4_WORD2_CLONE_BLKSIZE;
49524831 	}
....@@ -5001,6 +4880,11 @@
50014880 	if (status)
50024881 		goto xdr_error;
50034882 
4883
+	status = decode_attr_xattrsupport(xdr, bitmap,
4884
+					  &fsinfo->xattr_support);
4885
+	if (status)
4886
+		goto xdr_error;
4887
+
50044888 	status = verify_attr_len(xdr, savep, attrlen);
50054889 xdr_error:
50064890 	dprintk("%s: xdr returned %d!\n", __func__, -status);
....@@ -5022,19 +4906,16 @@
50224906 
50234907 	p = xdr_inline_decode(xdr, 4);
50244908 	if (unlikely(!p))
5025
-		goto out_overflow;
4909
+		return -EIO;
50264910 	len = be32_to_cpup(p);
50274911 	if (len > NFS4_FHSIZE)
50284912 		return -EIO;
50294913 	fh->size = len;
50304914 	p = xdr_inline_decode(xdr, len);
50314915 	if (unlikely(!p))
5032
-		goto out_overflow;
4916
+		return -EIO;
50334917 	memcpy(fh->data, p, len);
50344918 	return 0;
5035
-out_overflow:
5036
-	print_overflow_msg(__func__, xdr);
5037
-	return -EIO;
50384919 }
50394920 
50404921 static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
....@@ -5058,7 +4939,7 @@
50584939 
50594940 	p = xdr_inline_decode(xdr, 32); /* read 32 bytes */
50604941 	if (unlikely(!p))
5061
-		goto out_overflow;
4942
+		return -EIO;
50624943 	p = xdr_decode_hyper(p, &offset); /* read 2 8-byte long words */
50634944 	p = xdr_decode_hyper(p, &length);
50644945 	type = be32_to_cpup(p++); /* 4 byte read */
....@@ -5075,11 +4956,9 @@
50754956 	p = xdr_decode_hyper(p, &clientid); /* read 8 bytes */
50764957 	namelen = be32_to_cpup(p); /* read 4 bytes */  /* have read all 32 bytes now */
50774958 	p = xdr_inline_decode(xdr, namelen); /* variable size field */
5078
-	if (likely(p))
5079
-		return -NFS4ERR_DENIED;
5080
-out_overflow:
5081
-	print_overflow_msg(__func__, xdr);
5082
-	return -EIO;
4959
+	if (likely(!p))
4960
+		return -EIO;
4961
+	return -NFS4ERR_DENIED;
50834962 }
50844963 
50854964 static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
....@@ -5148,7 +5027,7 @@
51485027 
51495028 	p = xdr_inline_decode(xdr, 12);
51505029 	if (unlikely(!p))
5151
-		goto out_overflow;
5030
+		return -EIO;
51525031 	limit_type = be32_to_cpup(p++);
51535032 	switch (limit_type) {
51545033 	case NFS4_LIMIT_SIZE:
....@@ -5162,9 +5041,6 @@
51625041 	maxsize >>= PAGE_SHIFT;
51635042 	*pagemod_limit = min_t(u64, maxsize, ULONG_MAX);
51645043 	return 0;
5165
-out_overflow:
5166
-	print_overflow_msg(__func__, xdr);
5167
-	return -EIO;
51685044 }
51695045 
51705046 static int decode_rw_delegation(struct xdr_stream *xdr,
....@@ -5179,7 +5055,7 @@
51795055 		return status;
51805056 	p = xdr_inline_decode(xdr, 4);
51815057 	if (unlikely(!p))
5182
-		goto out_overflow;
5058
+		return -EIO;
51835059 	res->do_recall = be32_to_cpup(p);
51845060 
51855061 	switch (delegation_type) {
....@@ -5192,9 +5068,6 @@
51925068 				return -EIO;
51935069 	}
51945070 	return decode_ace(xdr, NULL);
5195
-out_overflow:
5196
-	print_overflow_msg(__func__, xdr);
5197
-	return -EIO;
51985071 }
51995072 
52005073 static int decode_no_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
....@@ -5204,7 +5077,7 @@
52045077 
52055078 	p = xdr_inline_decode(xdr, 4);
52065079 	if (unlikely(!p))
5207
-		goto out_overflow;
5080
+		return -EIO;
52085081 	why_no_delegation = be32_to_cpup(p);
52095082 	switch (why_no_delegation) {
52105083 		case WND4_CONTENTION:
....@@ -5213,9 +5086,6 @@
52135086 			/* Ignore for now */
52145087 	}
52155088 	return 0;
5216
-out_overflow:
5217
-	print_overflow_msg(__func__, xdr);
5218
-	return -EIO;
52195089 }
52205090 
52215091 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
....@@ -5225,7 +5095,7 @@
52255095 
52265096 	p = xdr_inline_decode(xdr, 4);
52275097 	if (unlikely(!p))
5228
-		goto out_overflow;
5098
+		return -EIO;
52295099 	delegation_type = be32_to_cpup(p);
52305100 	res->delegation_type = 0;
52315101 	switch (delegation_type) {
....@@ -5237,9 +5107,6 @@
52375107 	case NFS4_OPEN_DELEGATE_NONE_EXT:
52385108 		return decode_no_delegation(xdr, res);
52395109 	}
5240
-	return -EIO;
5241
-out_overflow:
5242
-	print_overflow_msg(__func__, xdr);
52435110 	return -EIO;
52445111 }
52455112 
....@@ -5262,7 +5129,7 @@
52625129 
52635130 	p = xdr_inline_decode(xdr, 8);
52645131 	if (unlikely(!p))
5265
-		goto out_overflow;
5132
+		return -EIO;
52665133 	res->rflags = be32_to_cpup(p++);
52675134 	bmlen = be32_to_cpup(p);
52685135 	if (bmlen > 10)
....@@ -5270,7 +5137,7 @@
52705137 
52715138 	p = xdr_inline_decode(xdr, bmlen << 2);
52725139 	if (unlikely(!p))
5273
-		goto out_overflow;
5140
+		return -EIO;
52745141 	savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
52755142 	for (i = 0; i < savewords; ++i)
52765143 		res->attrset[i] = be32_to_cpup(p++);
....@@ -5280,9 +5147,6 @@
52805147 	return decode_delegation(xdr, res);
52815148 xdr_error:
52825149 	dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
5283
-	return -EIO;
5284
-out_overflow:
5285
-	print_overflow_msg(__func__, xdr);
52865150 	return -EIO;
52875151 }
52885152 
....@@ -5332,7 +5196,7 @@
53325196 		return status;
53335197 	p = xdr_inline_decode(xdr, 8);
53345198 	if (unlikely(!p))
5335
-		goto out_overflow;
5199
+		return -EIO;
53365200 	eof = be32_to_cpup(p++);
53375201 	count = be32_to_cpup(p);
53385202 	recvd = xdr_read_pages(xdr, count);
....@@ -5345,9 +5209,6 @@
53455209 	res->eof = eof;
53465210 	res->count = count;
53475211 	return 0;
5348
-out_overflow:
5349
-	print_overflow_msg(__func__, xdr);
5350
-	return -EIO;
53515212 }
53525213 
53535214 static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
....@@ -5380,7 +5241,7 @@
53805241 	/* Convert length of symlink */
53815242 	p = xdr_inline_decode(xdr, 4);
53825243 	if (unlikely(!p))
5383
-		goto out_overflow;
5244
+		return -EIO;
53845245 	len = be32_to_cpup(p);
53855246 	if (len >= rcvbuf->page_len || len <= 0) {
53865247 		dprintk("nfs: server returned giant symlink!\n");
....@@ -5396,14 +5257,11 @@
53965257 	 * The XDR encode routine has set things up so that
53975258 	 * the link text will be copied directly into the
53985259 	 * buffer.  We just have to do overflow-checking,
5399
-	 * and and null-terminate the text (the VFS expects
5260
+	 * and null-terminate the text (the VFS expects
54005261 	 * null-termination).
54015262 	 */
54025263 	xdr_terminate_string(rcvbuf, len);
54035264 	return 0;
5404
-out_overflow:
5405
-	print_overflow_msg(__func__, xdr);
5406
-	return -EIO;
54075265 }
54085266 
54095267 static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
....@@ -5451,16 +5309,12 @@
54515309 	uint32_t attrlen,
54525310 		 bitmap[3] = {0};
54535311 	int status;
5454
-	unsigned int pg_offset;
54555312 
54565313 	res->acl_len = 0;
54575314 	if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
54585315 		goto out;
54595316 
54605317 	xdr_enter_page(xdr, xdr->buf->page_len);
5461
-
5462
-	/* Calculate the offset of the page data */
5463
-	pg_offset = xdr->buf->head[0].iov_len;
54645318 
54655319 	if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
54665320 		goto out;
....@@ -5474,7 +5328,7 @@
54745328 		/* The bitmap (xdr len + bitmaps) and the attr xdr len words
54755329 		 * are stored with the acl data to handle the problem of
54765330 		 * variable length bitmaps.*/
5477
-		res->acl_data_offset = xdr_stream_pos(xdr) - pg_offset;
5331
+		res->acl_data_offset = xdr_page_pos(xdr);
54785332 		res->acl_len = attrlen;
54795333 
54805334 		/* Check for receive buffer overflow */
....@@ -5506,7 +5360,6 @@
55065360 		return status;
55075361 	if (decode_bitmap4(xdr, NULL, 0) >= 0)
55085362 		return 0;
5509
-	print_overflow_msg(__func__, xdr);
55105363 	return -EIO;
55115364 }
55125365 
....@@ -5518,7 +5371,7 @@
55185371 
55195372 	p = xdr_inline_decode(xdr, 8);
55205373 	if (unlikely(!p))
5521
-		goto out_overflow;
5374
+		return -EIO;
55225375 	opnum = be32_to_cpup(p++);
55235376 	if (opnum != OP_SETCLIENTID) {
55245377 		dprintk("nfs: decode_setclientid: Server returned operation"
....@@ -5529,7 +5382,7 @@
55295382 	if (nfserr == NFS_OK) {
55305383 		p = xdr_inline_decode(xdr, 8 + NFS4_VERIFIER_SIZE);
55315384 		if (unlikely(!p))
5532
-			goto out_overflow;
5385
+			return -EIO;
55335386 		p = xdr_decode_hyper(p, &res->clientid);
55345387 		memcpy(res->confirm.data, p, NFS4_VERIFIER_SIZE);
55355388 	} else if (nfserr == NFSERR_CLID_INUSE) {
....@@ -5538,28 +5391,25 @@
55385391 		/* skip netid string */
55395392 		p = xdr_inline_decode(xdr, 4);
55405393 		if (unlikely(!p))
5541
-			goto out_overflow;
5394
+			return -EIO;
55425395 		len = be32_to_cpup(p);
55435396 		p = xdr_inline_decode(xdr, len);
55445397 		if (unlikely(!p))
5545
-			goto out_overflow;
5398
+			return -EIO;
55465399 
55475400 		/* skip uaddr string */
55485401 		p = xdr_inline_decode(xdr, 4);
55495402 		if (unlikely(!p))
5550
-			goto out_overflow;
5403
+			return -EIO;
55515404 		len = be32_to_cpup(p);
55525405 		p = xdr_inline_decode(xdr, len);
55535406 		if (unlikely(!p))
5554
-			goto out_overflow;
5407
+			return -EIO;
55555408 		return -NFSERR_CLID_INUSE;
55565409 	} else
55575410 		return nfs4_stat_to_errno(nfserr);
55585411 
55595412 	return 0;
5560
-out_overflow:
5561
-	print_overflow_msg(__func__, xdr);
5562
-	return -EIO;
55635413 }
55645414 
55655415 static int decode_setclientid_confirm(struct xdr_stream *xdr)
....@@ -5578,13 +5428,10 @@
55785428 
55795429 	p = xdr_inline_decode(xdr, 8);
55805430 	if (unlikely(!p))
5581
-		goto out_overflow;
5431
+		return -EIO;
55825432 	res->count = be32_to_cpup(p++);
55835433 	res->verf->committed = be32_to_cpup(p++);
55845434 	return decode_write_verifier(xdr, &res->verf->verifier);
5585
-out_overflow:
5586
-	print_overflow_msg(__func__, xdr);
5587
-	return -EIO;
55885435 }
55895436 
55905437 static int decode_delegreturn(struct xdr_stream *xdr)
....@@ -5600,30 +5447,24 @@
56005447 
56015448 	p = xdr_inline_decode(xdr, 4);
56025449 	if (unlikely(!p))
5603
-		goto out_overflow;
5450
+		return -EIO;
56045451 	oid_len = be32_to_cpup(p);
56055452 	if (oid_len > GSS_OID_MAX_LEN)
5606
-		goto out_err;
5453
+		return -EINVAL;
56075454 
56085455 	p = xdr_inline_decode(xdr, oid_len);
56095456 	if (unlikely(!p))
5610
-		goto out_overflow;
5457
+		return -EIO;
56115458 	memcpy(flavor->flavor_info.oid.data, p, oid_len);
56125459 	flavor->flavor_info.oid.len = oid_len;
56135460 
56145461 	p = xdr_inline_decode(xdr, 8);
56155462 	if (unlikely(!p))
5616
-		goto out_overflow;
5463
+		return -EIO;
56175464 	flavor->flavor_info.qop = be32_to_cpup(p++);
56185465 	flavor->flavor_info.service = be32_to_cpup(p);
56195466 
56205467 	return 0;
5621
-
5622
-out_overflow:
5623
-	print_overflow_msg(__func__, xdr);
5624
-	return -EIO;
5625
-out_err:
5626
-	return -EINVAL;
56275468 }
56285469 
56295470 static int decode_secinfo_common(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
....@@ -5635,7 +5476,7 @@
56355476 
56365477 	p = xdr_inline_decode(xdr, 4);
56375478 	if (unlikely(!p))
5638
-		goto out_overflow;
5479
+		return -EIO;
56395480 
56405481 	res->flavors->num_flavors = 0;
56415482 	num_flavors = be32_to_cpup(p);
....@@ -5647,7 +5488,7 @@
56475488 
56485489 		p = xdr_inline_decode(xdr, 4);
56495490 		if (unlikely(!p))
5650
-			goto out_overflow;
5491
+			return -EIO;
56515492 		sec_flavor->flavor = be32_to_cpup(p);
56525493 
56535494 		if (sec_flavor->flavor == RPC_AUTH_GSS) {
....@@ -5661,9 +5502,6 @@
56615502 	status = 0;
56625503 out:
56635504 	return status;
5664
-out_overflow:
5665
-	print_overflow_msg(__func__, xdr);
5666
-	return -EIO;
56675505 }
56685506 
56695507 static int decode_secinfo(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
....@@ -5717,11 +5555,11 @@
57175555 
57185556 	p = xdr_inline_decode(xdr, 8);
57195557 	if (unlikely(!p))
5720
-		goto out_overflow;
5558
+		return -EIO;
57215559 	xdr_decode_hyper(p, &res->clientid);
57225560 	p = xdr_inline_decode(xdr, 12);
57235561 	if (unlikely(!p))
5724
-		goto out_overflow;
5562
+		return -EIO;
57255563 	res->seqid = be32_to_cpup(p++);
57265564 	res->flags = be32_to_cpup(p++);
57275565 
....@@ -5745,7 +5583,7 @@
57455583 	/* server_owner4.so_minor_id */
57465584 	p = xdr_inline_decode(xdr, 8);
57475585 	if (unlikely(!p))
5748
-		goto out_overflow;
5586
+		return -EIO;
57495587 	p = xdr_decode_hyper(p, &res->server_owner->minor_id);
57505588 
57515589 	/* server_owner4.so_major_id */
....@@ -5765,7 +5603,7 @@
57655603 	/* Implementation Id */
57665604 	p = xdr_inline_decode(xdr, 4);
57675605 	if (unlikely(!p))
5768
-		goto out_overflow;
5606
+		return -EIO;
57695607 	impl_id_count = be32_to_cpup(p++);
57705608 
57715609 	if (impl_id_count) {
....@@ -5784,16 +5622,13 @@
57845622 		/* nii_date */
57855623 		p = xdr_inline_decode(xdr, 12);
57865624 		if (unlikely(!p))
5787
-			goto out_overflow;
5625
+			return -EIO;
57885626 		p = xdr_decode_hyper(p, &res->impl_id->date.seconds);
57895627 		res->impl_id->date.nseconds = be32_to_cpup(p);
57905628 
57915629 		/* if there's more than one entry, ignore the rest */
57925630 	}
57935631 	return 0;
5794
-out_overflow:
5795
-	print_overflow_msg(__func__, xdr);
5796
-	return -EIO;
57975632 }
57985633 
57995634 static int decode_chan_attrs(struct xdr_stream *xdr,
....@@ -5804,7 +5639,7 @@
58045639 
58055640 	p = xdr_inline_decode(xdr, 28);
58065641 	if (unlikely(!p))
5807
-		goto out_overflow;
5642
+		return -EIO;
58085643 	val = be32_to_cpup(p++);	/* headerpadsz */
58095644 	if (val)
58105645 		return -EINVAL;		/* no support for header padding yet */
....@@ -5822,12 +5657,9 @@
58225657 	if (nr_attrs == 1) {
58235658 		p = xdr_inline_decode(xdr, 4); /* skip rdma_attrs */
58245659 		if (unlikely(!p))
5825
-			goto out_overflow;
5660
+			return -EIO;
58265661 	}
58275662 	return 0;
5828
-out_overflow:
5829
-	print_overflow_msg(__func__, xdr);
5830
-	return -EIO;
58315663 }
58325664 
58335665 static int decode_sessionid(struct xdr_stream *xdr, struct nfs4_sessionid *sid)
....@@ -5850,7 +5682,7 @@
58505682 	/* dir flags, rdma mode bool */
58515683 	p = xdr_inline_decode(xdr, 8);
58525684 	if (unlikely(!p))
5853
-		goto out_overflow;
5685
+		return -EIO;
58545686 
58555687 	res->dir = be32_to_cpup(p++);
58565688 	if (res->dir == 0 || res->dir > NFS4_CDFS4_BOTH)
....@@ -5861,9 +5693,6 @@
58615693 		res->use_conn_in_rdma_mode = true;
58625694 
58635695 	return 0;
5864
-out_overflow:
5865
-	print_overflow_msg(__func__, xdr);
5866
-	return -EIO;
58675696 }
58685697 
58695698 static int decode_create_session(struct xdr_stream *xdr,
....@@ -5881,7 +5710,7 @@
58815710 	/* seqid, flags */
58825711 	p = xdr_inline_decode(xdr, 8);
58835712 	if (unlikely(!p))
5884
-		goto out_overflow;
5713
+		return -EIO;
58855714 	res->seqid = be32_to_cpup(p++);
58865715 	res->flags = be32_to_cpup(p);
58875716 
....@@ -5890,9 +5719,6 @@
58905719 	if (!status)
58915720 		status = decode_chan_attrs(xdr, &res->bc_attrs);
58925721 	return status;
5893
-out_overflow:
5894
-	print_overflow_msg(__func__, xdr);
5895
-	return -EIO;
58965722 }
58975723 
58985724 static int decode_destroy_session(struct xdr_stream *xdr, void *dummy)
....@@ -5973,7 +5799,6 @@
59735799 	res->sr_status = status;
59745800 	return status;
59755801 out_overflow:
5976
-	print_overflow_msg(__func__, xdr);
59775802 	status = -EIO;
59785803 	goto out_err;
59795804 #else  /* CONFIG_NFS_V4_1 */
....@@ -6001,7 +5826,7 @@
60015826 		if (status == -ETOOSMALL) {
60025827 			p = xdr_inline_decode(xdr, 4);
60035828 			if (unlikely(!p))
6004
-				goto out_overflow;
5829
+				return -EIO;
60055830 			pdev->mincount = be32_to_cpup(p);
60065831 			dprintk("%s: Min count too small. mincnt = %u\n",
60075832 				__func__, pdev->mincount);
....@@ -6011,7 +5836,7 @@
60115836 
60125837 	p = xdr_inline_decode(xdr, 8);
60135838 	if (unlikely(!p))
6014
-		goto out_overflow;
5839
+		return -EIO;
60155840 	type = be32_to_cpup(p++);
60165841 	if (type != pdev->layout_type) {
60175842 		dprintk("%s: layout mismatch req: %u pdev: %u\n",
....@@ -6025,19 +5850,19 @@
60255850 	 */
60265851 	pdev->mincount = be32_to_cpup(p);
60275852 	if (xdr_read_pages(xdr, pdev->mincount) != pdev->mincount)
6028
-		goto out_overflow;
5853
+		return -EIO;
60295854 
60305855 	/* Parse notification bitmap, verifying that it is zero. */
60315856 	p = xdr_inline_decode(xdr, 4);
60325857 	if (unlikely(!p))
6033
-		goto out_overflow;
5858
+		return -EIO;
60345859 	len = be32_to_cpup(p);
60355860 	if (len) {
60365861 		uint32_t i;
60375862 
60385863 		p = xdr_inline_decode(xdr, 4 * len);
60395864 		if (unlikely(!p))
6040
-			goto out_overflow;
5865
+			return -EIO;
60415866 
60425867 		res->notification = be32_to_cpup(p++);
60435868 		for (i = 1; i < len; i++) {
....@@ -6049,9 +5874,6 @@
60495874 		}
60505875 	}
60515876 	return 0;
6052
-out_overflow:
6053
-	print_overflow_msg(__func__, xdr);
6054
-	return -EIO;
60555877 }
60565878 
60575879 static int decode_layoutget(struct xdr_stream *xdr, struct rpc_rqst *req,
....@@ -6121,7 +5943,6 @@
61215943 	res->status = status;
61225944 	return status;
61235945 out_overflow:
6124
-	print_overflow_msg(__func__, xdr);
61255946 	status = -EIO;
61265947 	goto out;
61275948 }
....@@ -6137,16 +5958,13 @@
61375958 		return status;
61385959 	p = xdr_inline_decode(xdr, 4);
61395960 	if (unlikely(!p))
6140
-		goto out_overflow;
5961
+		return -EIO;
61415962 	res->lrs_present = be32_to_cpup(p);
61425963 	if (res->lrs_present)
61435964 		status = decode_layout_stateid(xdr, &res->stateid);
61445965 	else
61455966 		nfs4_stateid_copy(&res->stateid, &invalid_stateid);
61465967 	return status;
6147
-out_overflow:
6148
-	print_overflow_msg(__func__, xdr);
6149
-	return -EIO;
61505968 }
61515969 
61525970 static int decode_layoutcommit(struct xdr_stream *xdr,
....@@ -6164,19 +5982,16 @@
61645982 
61655983 	p = xdr_inline_decode(xdr, 4);
61665984 	if (unlikely(!p))
6167
-		goto out_overflow;
5985
+		return -EIO;
61685986 	sizechanged = be32_to_cpup(p);
61695987 
61705988 	if (sizechanged) {
61715989 		/* throw away new size */
61725990 		p = xdr_inline_decode(xdr, 8);
61735991 		if (unlikely(!p))
6174
-			goto out_overflow;
5992
+			return -EIO;
61755993 	}
61765994 	return 0;
6177
-out_overflow:
6178
-	print_overflow_msg(__func__, xdr);
6179
-	return -EIO;
61805995 }
61815996 
61825997 static int decode_test_stateid(struct xdr_stream *xdr,
....@@ -6192,21 +6007,17 @@
61926007 
61936008 	p = xdr_inline_decode(xdr, 4);
61946009 	if (unlikely(!p))
6195
-		goto out_overflow;
6010
+		return -EIO;
61966011 	num_res = be32_to_cpup(p++);
61976012 	if (num_res != 1)
6198
-		goto out;
6013
+		return -EIO;
61996014 
62006015 	p = xdr_inline_decode(xdr, 4);
62016016 	if (unlikely(!p))
6202
-		goto out_overflow;
6017
+		return -EIO;
62036018 	res->status = be32_to_cpup(p++);
62046019 
62056020 	return status;
6206
-out_overflow:
6207
-	print_overflow_msg(__func__, xdr);
6208
-out:
6209
-	return -EIO;
62106021 }
62116022 
62126023 static int decode_free_stateid(struct xdr_stream *xdr,
....@@ -7343,6 +7154,8 @@
73437154 	return status;
73447155 }
73457156 
7157
+#endif
7158
+
73467159 /*
73477160  * Decode GET_LEASE_TIME response
73487161  */
....@@ -7363,6 +7176,8 @@
73637176 		status = decode_fsinfo(xdr, res->lr_fsinfo);
73647177 	return status;
73657178 }
7179
+
7180
+#ifdef CONFIG_NFS_V4_1
73667181 
73677182 /*
73687183  * Decode RECLAIM_COMPLETE response
....@@ -7576,11 +7391,11 @@
75767391 	uint64_t new_cookie;
75777392 	__be32 *p = xdr_inline_decode(xdr, 4);
75787393 	if (unlikely(!p))
7579
-		goto out_overflow;
7394
+		return -EAGAIN;
75807395 	if (*p == xdr_zero) {
75817396 		p = xdr_inline_decode(xdr, 4);
75827397 		if (unlikely(!p))
7583
-			goto out_overflow;
7398
+			return -EAGAIN;
75847399 		if (*p == xdr_zero)
75857400 			return -EAGAIN;
75867401 		entry->eof = 1;
....@@ -7589,13 +7404,13 @@
75897404 
75907405 	p = xdr_inline_decode(xdr, 12);
75917406 	if (unlikely(!p))
7592
-		goto out_overflow;
7407
+		return -EAGAIN;
75937408 	p = xdr_decode_hyper(p, &new_cookie);
75947409 	entry->len = be32_to_cpup(p);
75957410 
75967411 	p = xdr_inline_decode(xdr, entry->len);
75977412 	if (unlikely(!p))
7598
-		goto out_overflow;
7413
+		return -EAGAIN;
75997414 	entry->name = (const char *) p;
76007415 
76017416 	/*
....@@ -7607,14 +7422,14 @@
76077422 	entry->fattr->valid = 0;
76087423 
76097424 	if (decode_attr_bitmap(xdr, bitmap) < 0)
7610
-		goto out_overflow;
7425
+		return -EAGAIN;
76117426 
76127427 	if (decode_attr_length(xdr, &len, &savep) < 0)
7613
-		goto out_overflow;
7428
+		return -EAGAIN;
76147429 
76157430 	if (decode_getfattr_attrs(xdr, bitmap, entry->fattr, entry->fh,
76167431 			NULL, entry->label, entry->server) < 0)
7617
-		goto out_overflow;
7432
+		return -EAGAIN;
76187433 	if (entry->fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
76197434 		entry->ino = entry->fattr->mounted_on_fileid;
76207435 	else if (entry->fattr->valid & NFS_ATTR_FATTR_FILEID)
....@@ -7628,10 +7443,6 @@
76287443 	entry->cookie = new_cookie;
76297444 
76307445 	return 0;
7631
-
7632
-out_overflow:
7633
-	print_overflow_msg(__func__, xdr);
7634
-	return -EAGAIN;
76357446 }
76367447 
76377448 /*
....@@ -7671,6 +7482,8 @@
76717482 	{ NFS4ERR_SYMLINK,	-ELOOP		},
76727483 	{ NFS4ERR_OP_ILLEGAL,	-EOPNOTSUPP	},
76737484 	{ NFS4ERR_DEADLOCK,	-EDEADLK	},
7485
+	{ NFS4ERR_NOXATTR,	-ENODATA	},
7486
+	{ NFS4ERR_XATTR2BIG,	-E2BIG		},
76747487 	{ -1,			-EIO		}
76757488 };
76767489 
....@@ -7776,7 +7589,7 @@
77767589 	PROC41(CREATE_SESSION,	enc_create_session,	dec_create_session),
77777590 	PROC41(DESTROY_SESSION,	enc_destroy_session,	dec_destroy_session),
77787591 	PROC41(SEQUENCE,	enc_sequence,		dec_sequence),
7779
-	PROC41(GET_LEASE_TIME,	enc_get_lease_time,	dec_get_lease_time),
7592
+	PROC(GET_LEASE_TIME,	enc_get_lease_time,	dec_get_lease_time),
77807593 	PROC41(RECLAIM_COMPLETE,enc_reclaim_complete,	dec_reclaim_complete),
77817594 	PROC41(GETDEVICEINFO,	enc_getdeviceinfo,	dec_getdeviceinfo),
77827595 	PROC41(LAYOUTGET,	enc_layoutget,		dec_layoutget),
....@@ -7796,7 +7609,14 @@
77967609 	PROC42(CLONE,		enc_clone,		dec_clone),
77977610 	PROC42(COPY,		enc_copy,		dec_copy),
77987611 	PROC42(OFFLOAD_CANCEL,	enc_offload_cancel,	dec_offload_cancel),
7612
+	PROC42(COPY_NOTIFY,	enc_copy_notify,	dec_copy_notify),
77997613 	PROC(LOOKUPP,		enc_lookupp,		dec_lookupp),
7614
+	PROC42(LAYOUTERROR,	enc_layouterror,	dec_layouterror),
7615
+	PROC42(GETXATTR,	enc_getxattr,		dec_getxattr),
7616
+	PROC42(SETXATTR,	enc_setxattr,		dec_setxattr),
7617
+	PROC42(LISTXATTRS,	enc_listxattrs,		dec_listxattrs),
7618
+	PROC42(REMOVEXATTR,	enc_removexattr,	dec_removexattr),
7619
+	PROC42(READ_PLUS,	enc_read_plus,		dec_read_plus),
78007620 };
78017621 
78027622 static unsigned int nfs_version4_counts[ARRAY_SIZE(nfs4_procedures)];