Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'nfs-for-5.0-2' of git://git.linux-nfs.org/projects/anna/linux-nfs
Pull NFS client fixes from Anna Schumaker:
"These are mostly fixes for SUNRPC bugs, with a single v4.2
copy_file_range() fix mixed in.
Stable bugfixes:
- Fix TCP receive code on archs with flush_dcache_page()
Other bugfixes:
- Fix error code in rpcrdma_buffer_create()
- Fix a double free in rpcrdma_send_ctxs_create()
- Fix kernel BUG at kernel/cred.c:825
- Fix unnecessary retry in nfs42_proc_copy_file_range()
- Ensure rq_bytes_sent is reset before request transmission
- Ensure we respect the RPCSEC_GSS sequence number limit
- Address Kerberos performance/behavior regression"
* tag 'nfs-for-5.0-2' of git://git.linux-nfs.org/projects/anna/linux-nfs:
SUNRPC: Address Kerberos performance/behavior regression
SUNRPC: Ensure we respect the RPCSEC_GSS sequence number limit
SUNRPC: Ensure rq_bytes_sent is reset before request transmission
NFSv4.2 fix unnecessary retry in nfs4_copy_file_range
sunrpc: kernel BUG at kernel/cred.c:825!
SUNRPC: Fix TCP receive code on archs with flush_dcache_page()
xprtrdma: Double free in rpcrdma_sendctxs_create()
xprtrdma: Fix error code in rpcrdma_buffer_create()
+53
-25
+1
-7
fs/nfs/nfs4file.c
+1
-7
fs/nfs/nfs4file.c
···
133
133
struct file *file_out, loff_t pos_out,
134
134
size_t count, unsigned int flags)
135
135
{
136
-
ssize_t ret;
137
-
138
136
if (file_inode(file_in) == file_inode(file_out))
139
137
return -EINVAL;
140
-
retry:
141
-
ret = nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count);
142
-
if (ret == -EAGAIN)
143
-
goto retry;
144
-
return ret;
138
+
return nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count);
145
139
}
146
140
147
141
static loff_t nfs4_file_llseek(struct file *filep, loff_t offset, int whence)
+3
net/sunrpc/auth.c
+3
net/sunrpc/auth.c
+9
-3
net/sunrpc/auth_gss/auth_gss.c
+9
-3
net/sunrpc/auth_gss/auth_gss.c
···
1549
1549
cred_len = p++;
1550
1550
1551
1551
spin_lock(&ctx->gc_seq_lock);
1552
-
req->rq_seqno = ctx->gc_seq++;
1552
+
req->rq_seqno = (ctx->gc_seq < MAXSEQ) ? ctx->gc_seq++ : MAXSEQ;
1553
1553
spin_unlock(&ctx->gc_seq_lock);
1554
+
if (req->rq_seqno == MAXSEQ)
1555
+
goto out_expired;
1554
1556
1555
1557
*p++ = htonl((u32) RPC_GSS_VERSION);
1556
1558
*p++ = htonl((u32) ctx->gc_proc);
···
1574
1572
mic.data = (u8 *)(p + 1);
1575
1573
maj_stat = gss_get_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
1576
1574
if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
1577
-
clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1575
+
goto out_expired;
1578
1576
} else if (maj_stat != 0) {
1579
-
printk("gss_marshal: gss_get_mic FAILED (%d)\n", maj_stat);
1577
+
pr_warn("gss_marshal: gss_get_mic FAILED (%d)\n", maj_stat);
1578
+
task->tk_status = -EIO;
1580
1579
goto out_put_ctx;
1581
1580
}
1582
1581
p = xdr_encode_opaque(p, NULL, mic.len);
1583
1582
gss_put_ctx(ctx);
1584
1583
return p;
1584
+
out_expired:
1585
+
clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1586
+
task->tk_status = -EKEYEXPIRED;
1585
1587
out_put_ctx:
1586
1588
gss_put_ctx(ctx);
1587
1589
return NULL;
+12
-8
net/sunrpc/clnt.c
+12
-8
net/sunrpc/clnt.c
···
1739
1739
xdr_buf_init(&req->rq_rcv_buf,
1740
1740
req->rq_rbuffer,
1741
1741
req->rq_rcvsize);
1742
-
req->rq_bytes_sent = 0;
1743
1742
1744
1743
p = rpc_encode_header(task);
1745
-
if (p == NULL) {
1746
-
printk(KERN_INFO "RPC: couldn't encode RPC header, exit EIO\n");
1747
-
rpc_exit(task, -EIO);
1744
+
if (p == NULL)
1748
1745
return;
1749
-
}
1750
1746
1751
1747
encode = task->tk_msg.rpc_proc->p_encode;
1752
1748
if (encode == NULL)
···
1767
1771
/* Did the encode result in an error condition? */
1768
1772
if (task->tk_status != 0) {
1769
1773
/* Was the error nonfatal? */
1770
-
if (task->tk_status == -EAGAIN || task->tk_status == -ENOMEM)
1774
+
switch (task->tk_status) {
1775
+
case -EAGAIN:
1776
+
case -ENOMEM:
1771
1777
rpc_delay(task, HZ >> 4);
1772
-
else
1778
+
break;
1779
+
case -EKEYEXPIRED:
1780
+
task->tk_action = call_refresh;
1781
+
break;
1782
+
default:
1773
1783
rpc_exit(task, task->tk_status);
1784
+
}
1774
1785
return;
1775
1786
}
1776
1787
···
2339
2336
*p++ = htonl(clnt->cl_vers); /* program version */
2340
2337
*p++ = htonl(task->tk_msg.rpc_proc->p_proc); /* procedure */
2341
2338
p = rpcauth_marshcred(task, p);
2342
-
req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);
2339
+
if (p)
2340
+
req->rq_slen = xdr_adjust_iovec(&req->rq_svec[0], p);
2343
2341
return p;
2344
2342
}
2345
2343
+2
-1
net/sunrpc/xprt.c
+2
-1
net/sunrpc/xprt.c
···
1151
1151
struct rpc_xprt *xprt = req->rq_xprt;
1152
1152
1153
1153
if (xprt_request_need_enqueue_transmit(task, req)) {
1154
+
req->rq_bytes_sent = 0;
1154
1155
spin_lock(&xprt->queue_lock);
1155
1156
/*
1156
1157
* Requests that carry congestion control credits are added
···
1178
1177
INIT_LIST_HEAD(&req->rq_xmit2);
1179
1178
goto out;
1180
1179
}
1181
-
} else {
1180
+
} else if (!req->rq_seqno) {
1182
1181
list_for_each_entry(pos, &xprt->xmit_queue, rq_xmit) {
1183
1182
if (pos->rq_task->tk_owner != task->tk_owner)
1184
1183
continue;
+4
-6
net/sunrpc/xprtrdma/verbs.c
+4
-6
net/sunrpc/xprtrdma/verbs.c
···
845
845
for (i = 0; i <= buf->rb_sc_last; i++) {
846
846
sc = rpcrdma_sendctx_create(&r_xprt->rx_ia);
847
847
if (!sc)
848
-
goto out_destroy;
848
+
return -ENOMEM;
849
849
850
850
sc->sc_xprt = r_xprt;
851
851
buf->rb_sc_ctxs[i] = sc;
852
852
}
853
853
854
854
return 0;
855
-
856
-
out_destroy:
857
-
rpcrdma_sendctxs_destroy(buf);
858
-
return -ENOMEM;
859
855
}
860
856
861
857
/* The sendctx queue is not guaranteed to have a size that is a
···
1109
1113
WQ_MEM_RECLAIM | WQ_HIGHPRI,
1110
1114
0,
1111
1115
r_xprt->rx_xprt.address_strings[RPC_DISPLAY_ADDR]);
1112
-
if (!buf->rb_completion_wq)
1116
+
if (!buf->rb_completion_wq) {
1117
+
rc = -ENOMEM;
1113
1118
goto out;
1119
+
}
1114
1120
1115
1121
return 0;
1116
1122
out:
+22
net/sunrpc/xprtsock.c
+22
net/sunrpc/xprtsock.c
···
48
48
#include <net/udp.h>
49
49
#include <net/tcp.h>
50
50
#include <linux/bvec.h>
51
+
#include <linux/highmem.h>
51
52
#include <linux/uio.h>
52
53
53
54
#include <trace/events/sunrpc.h>
···
377
376
return sock_recvmsg(sock, msg, flags);
378
377
}
379
378
379
+
#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
380
+
static void
381
+
xs_flush_bvec(const struct bio_vec *bvec, size_t count, size_t seek)
382
+
{
383
+
struct bvec_iter bi = {
384
+
.bi_size = count,
385
+
};
386
+
struct bio_vec bv;
387
+
388
+
bvec_iter_advance(bvec, &bi, seek & PAGE_MASK);
389
+
for_each_bvec(bv, bvec, bi, bi)
390
+
flush_dcache_page(bv.bv_page);
391
+
}
392
+
#else
393
+
static inline void
394
+
xs_flush_bvec(const struct bio_vec *bvec, size_t count, size_t seek)
395
+
{
396
+
}
397
+
#endif
398
+
380
399
static ssize_t
381
400
xs_read_xdr_buf(struct socket *sock, struct msghdr *msg, int flags,
382
401
struct xdr_buf *buf, size_t count, size_t seek, size_t *read)
···
430
409
seek + buf->page_base);
431
410
if (ret <= 0)
432
411
goto sock_err;
412
+
xs_flush_bvec(buf->bvec, ret, seek + buf->page_base);
433
413
offset += ret - buf->page_base;
434
414
if (offset == count || msg->msg_flags & (MSG_EOR|MSG_TRUNC))
435
415
goto out;