Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-2.6.30' of git://linux-nfs.org/~bfields/linux
* 'for-2.6.30' of git://linux-nfs.org/~bfields/linux:
svcrdma: dma unmap the correct length for the RPCRDMA header page.
nfsd: Revert "svcrpc: take advantage of tcp autotuning"
nfsd: fix hung up of nfs client while sync write data to nfs server
+42
-21
+3
-3
fs/nfsd/vfs.c
+3
-3
fs/nfsd/vfs.c
···
1015
1015
host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &offset);
1016
1016
set_fs(oldfs);
1017
1017
if (host_err >= 0) {
1018
+
*cnt = host_err;
1018
1019
nfsdstats.io_write += host_err;
1019
1020
fsnotify_modify(file->f_path.dentry);
1020
1021
}
···
1061
1060
}
1062
1061
1063
1062
dprintk("nfsd: write complete host_err=%d\n", host_err);
1064
-
if (host_err >= 0) {
1063
+
if (host_err >= 0)
1065
1064
err = 0;
1066
-
*cnt = host_err;
1067
-
} else
1065
+
else
1068
1066
err = nfserrno(host_err);
1069
1067
out:
1070
1068
return err;
+28
-7
net/sunrpc/svcsock.c
+28
-7
net/sunrpc/svcsock.c
···
345
345
lock_sock(sock->sk);
346
346
sock->sk->sk_sndbuf = snd * 2;
347
347
sock->sk->sk_rcvbuf = rcv * 2;
348
+
sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK|SOCK_RCVBUF_LOCK;
348
349
release_sock(sock->sk);
349
350
#endif
350
351
}
···
797
796
test_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags),
798
797
test_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags));
799
798
799
+
if (test_and_clear_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags))
800
+
/* sndbuf needs to have room for one request
801
+
* per thread, otherwise we can stall even when the
802
+
* network isn't a bottleneck.
803
+
*
804
+
* We count all threads rather than threads in a
805
+
* particular pool, which provides an upper bound
806
+
* on the number of threads which will access the socket.
807
+
*
808
+
* rcvbuf just needs to be able to hold a few requests.
809
+
* Normally they will be removed from the queue
810
+
* as soon a a complete request arrives.
811
+
*/
812
+
svc_sock_setbufsize(svsk->sk_sock,
813
+
(serv->sv_nrthreads+3) * serv->sv_max_mesg,
814
+
3 * serv->sv_max_mesg);
815
+
800
816
clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
801
817
802
818
/* Receive data. If we haven't got the record length yet, get
···
1061
1043
1062
1044
tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
1063
1045
1046
+
/* initialise setting must have enough space to
1047
+
* receive and respond to one request.
1048
+
* svc_tcp_recvfrom will re-adjust if necessary
1049
+
*/
1050
+
svc_sock_setbufsize(svsk->sk_sock,
1051
+
3 * svsk->sk_xprt.xpt_server->sv_max_mesg,
1052
+
3 * svsk->sk_xprt.xpt_server->sv_max_mesg);
1053
+
1054
+
set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
1064
1055
set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
1065
1056
if (sk->sk_state != TCP_ESTABLISHED)
1066
1057
set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
···
1139
1112
/* Initialize the socket */
1140
1113
if (sock->type == SOCK_DGRAM)
1141
1114
svc_udp_init(svsk, serv);
1142
-
else {
1143
-
/* initialise setting must have enough space to
1144
-
* receive and respond to one request.
1145
-
*/
1146
-
svc_sock_setbufsize(svsk->sk_sock, 4 * serv->sv_max_mesg,
1147
-
4 * serv->sv_max_mesg);
1115
+
else
1148
1116
svc_tcp_init(svsk, serv);
1149
-
}
1150
1117
1151
1118
dprintk("svc: svc_setup_socket created %p (inet %p)\n",
1152
1119
svsk, svsk->sk_sk);
+6
-6
net/sunrpc/xprtrdma/svc_rdma_sendto.c
+6
-6
net/sunrpc/xprtrdma/svc_rdma_sendto.c
···
128
128
page_bytes -= sge_bytes;
129
129
130
130
frmr->page_list->page_list[page_no] =
131
-
ib_dma_map_page(xprt->sc_cm_id->device, page, 0,
131
+
ib_dma_map_single(xprt->sc_cm_id->device,
132
+
page_address(page),
132
133
PAGE_SIZE, DMA_TO_DEVICE);
133
134
if (ib_dma_mapping_error(xprt->sc_cm_id->device,
134
135
frmr->page_list->page_list[page_no]))
···
533
532
clear_bit(RDMACTXT_F_FAST_UNREG, &ctxt->flags);
534
533
535
534
/* Prepare the SGE for the RPCRDMA Header */
535
+
ctxt->sge[0].lkey = rdma->sc_dma_lkey;
536
+
ctxt->sge[0].length = svc_rdma_xdr_get_reply_hdr_len(rdma_resp);
536
537
ctxt->sge[0].addr =
537
-
ib_dma_map_page(rdma->sc_cm_id->device,
538
-
page, 0, PAGE_SIZE, DMA_TO_DEVICE);
538
+
ib_dma_map_single(rdma->sc_cm_id->device, page_address(page),
539
+
ctxt->sge[0].length, DMA_TO_DEVICE);
539
540
if (ib_dma_mapping_error(rdma->sc_cm_id->device, ctxt->sge[0].addr))
540
541
goto err;
541
542
atomic_inc(&rdma->sc_dma_used);
542
543
543
544
ctxt->direction = DMA_TO_DEVICE;
544
-
545
-
ctxt->sge[0].length = svc_rdma_xdr_get_reply_hdr_len(rdma_resp);
546
-
ctxt->sge[0].lkey = rdma->sc_dma_lkey;
547
545
548
546
/* Determine how many of our SGE are to be transmitted */
549
547
for (sge_no = 1; byte_count && sge_no < vec->count; sge_no++) {
+5
-5
net/sunrpc/xprtrdma/svc_rdma_transport.c
+5
-5
net/sunrpc/xprtrdma/svc_rdma_transport.c
···
500
500
BUG_ON(sge_no >= xprt->sc_max_sge);
501
501
page = svc_rdma_get_page();
502
502
ctxt->pages[sge_no] = page;
503
-
pa = ib_dma_map_page(xprt->sc_cm_id->device,
504
-
page, 0, PAGE_SIZE,
503
+
pa = ib_dma_map_single(xprt->sc_cm_id->device,
504
+
page_address(page), PAGE_SIZE,
505
505
DMA_FROM_DEVICE);
506
506
if (ib_dma_mapping_error(xprt->sc_cm_id->device, pa))
507
507
goto err_put_ctxt;
···
1315
1315
length = svc_rdma_xdr_encode_error(xprt, rmsgp, err, va);
1316
1316
1317
1317
/* Prepare SGE for local address */
1318
-
sge.addr = ib_dma_map_page(xprt->sc_cm_id->device,
1319
-
p, 0, PAGE_SIZE, DMA_FROM_DEVICE);
1318
+
sge.addr = ib_dma_map_single(xprt->sc_cm_id->device,
1319
+
page_address(p), PAGE_SIZE, DMA_FROM_DEVICE);
1320
1320
if (ib_dma_mapping_error(xprt->sc_cm_id->device, sge.addr)) {
1321
1321
put_page(p);
1322
1322
return;
···
1343
1343
if (ret) {
1344
1344
dprintk("svcrdma: Error %d posting send for protocol error\n",
1345
1345
ret);
1346
-
ib_dma_unmap_page(xprt->sc_cm_id->device,
1346
+
ib_dma_unmap_single(xprt->sc_cm_id->device,
1347
1347
sge.addr, PAGE_SIZE,
1348
1348
DMA_FROM_DEVICE);
1349
1349
svc_rdma_put_context(ctxt, 1);