1 // SPDX-License-Identifier: GPL-2.0-only
3 * linux/net/sunrpc/svcsock.c
5 * These are the RPC server socket internals.
7 * The server scheduling algorithm does not always distribute the load
8 * evenly when servicing a single client. May need to modify the
9 * svc_xprt_enqueue procedure...
11 * TCP support is largely untested and may be a little slow. The problem
12 * is that we currently do two separate recvfrom's, one for the 4-byte
13 * record length, and the second for the actual record. This could possibly
14 * be improved by always reading a minimum size of around 100 bytes and
15 * tucking any superfluous bytes away in a temporary store. Still, that
16 * leaves write requests out in the rain. An alternative may be to peek at
17 * the first skb in the queue, and if it matches the next TCP sequence
18 * number, to extract the record marker. Yuck.
20 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/module.h>
26 #include <linux/errno.h>
27 #include <linux/fcntl.h>
28 #include <linux/net.h>
30 #include <linux/inet.h>
31 #include <linux/udp.h>
32 #include <linux/tcp.h>
33 #include <linux/unistd.h>
34 #include <linux/slab.h>
35 #include <linux/netdevice.h>
36 #include <linux/skbuff.h>
37 #include <linux/file.h>
38 #include <linux/freezer.h>
40 #include <net/checksum.h>
45 #include <net/tcp_states.h>
46 #include <linux/uaccess.h>
47 #include <linux/highmem.h>
48 #include <asm/ioctls.h>
50 #include <linux/sunrpc/types.h>
51 #include <linux/sunrpc/clnt.h>
52 #include <linux/sunrpc/xdr.h>
53 #include <linux/sunrpc/msg_prot.h>
54 #include <linux/sunrpc/svcsock.h>
55 #include <linux/sunrpc/stats.h>
56 #include <linux/sunrpc/xprt.h>
58 #include <trace/events/sunrpc.h>
63 #define RPCDBG_FACILITY RPCDBG_SVCXPRT
66 static struct svc_sock
*svc_setup_socket(struct svc_serv
*, struct socket
*,
68 static int svc_udp_recvfrom(struct svc_rqst
*);
69 static int svc_udp_sendto(struct svc_rqst
*);
70 static void svc_sock_detach(struct svc_xprt
*);
71 static void svc_tcp_sock_detach(struct svc_xprt
*);
72 static void svc_sock_free(struct svc_xprt
*);
74 static struct svc_xprt
*svc_create_socket(struct svc_serv
*, int,
75 struct net
*, struct sockaddr
*,
77 #ifdef CONFIG_DEBUG_LOCK_ALLOC
78 static struct lock_class_key svc_key
[2];
79 static struct lock_class_key svc_slock_key
[2];
81 static void svc_reclassify_socket(struct socket
*sock
)
83 struct sock
*sk
= sock
->sk
;
85 if (WARN_ON_ONCE(!sock_allow_reclassification(sk
)))
88 switch (sk
->sk_family
) {
90 sock_lock_init_class_and_name(sk
, "slock-AF_INET-NFSD",
92 "sk_xprt.xpt_lock-AF_INET-NFSD",
97 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-NFSD",
99 "sk_xprt.xpt_lock-AF_INET6-NFSD",
108 static void svc_reclassify_socket(struct socket
*sock
)
114 * svc_tcp_release_rqst - Release transport-related resources
115 * @rqstp: request structure with resources to be released
118 static void svc_tcp_release_rqst(struct svc_rqst
*rqstp
)
120 struct sk_buff
*skb
= rqstp
->rq_xprt_ctxt
;
123 struct svc_sock
*svsk
=
124 container_of(rqstp
->rq_xprt
, struct svc_sock
, sk_xprt
);
126 rqstp
->rq_xprt_ctxt
= NULL
;
127 skb_free_datagram_locked(svsk
->sk_sk
, skb
);
132 * svc_udp_release_rqst - Release transport-related resources
133 * @rqstp: request structure with resources to be released
136 static void svc_udp_release_rqst(struct svc_rqst
*rqstp
)
138 struct sk_buff
*skb
= rqstp
->rq_xprt_ctxt
;
141 rqstp
->rq_xprt_ctxt
= NULL
;
146 union svc_pktinfo_u
{
147 struct in_pktinfo pkti
;
148 struct in6_pktinfo pkti6
;
150 #define SVC_PKTINFO_SPACE \
151 CMSG_SPACE(sizeof(union svc_pktinfo_u))
153 static void svc_set_cmsg_data(struct svc_rqst
*rqstp
, struct cmsghdr
*cmh
)
155 struct svc_sock
*svsk
=
156 container_of(rqstp
->rq_xprt
, struct svc_sock
, sk_xprt
);
157 switch (svsk
->sk_sk
->sk_family
) {
159 struct in_pktinfo
*pki
= CMSG_DATA(cmh
);
161 cmh
->cmsg_level
= SOL_IP
;
162 cmh
->cmsg_type
= IP_PKTINFO
;
163 pki
->ipi_ifindex
= 0;
164 pki
->ipi_spec_dst
.s_addr
=
165 svc_daddr_in(rqstp
)->sin_addr
.s_addr
;
166 cmh
->cmsg_len
= CMSG_LEN(sizeof(*pki
));
171 struct in6_pktinfo
*pki
= CMSG_DATA(cmh
);
172 struct sockaddr_in6
*daddr
= svc_daddr_in6(rqstp
);
174 cmh
->cmsg_level
= SOL_IPV6
;
175 cmh
->cmsg_type
= IPV6_PKTINFO
;
176 pki
->ipi6_ifindex
= daddr
->sin6_scope_id
;
177 pki
->ipi6_addr
= daddr
->sin6_addr
;
178 cmh
->cmsg_len
= CMSG_LEN(sizeof(*pki
));
184 static int svc_sock_result_payload(struct svc_rqst
*rqstp
, unsigned int offset
,
191 * Report socket names for nfsdfs
193 static int svc_one_sock_name(struct svc_sock
*svsk
, char *buf
, int remaining
)
195 const struct sock
*sk
= svsk
->sk_sk
;
196 const char *proto_name
= sk
->sk_protocol
== IPPROTO_UDP
?
200 switch (sk
->sk_family
) {
202 len
= snprintf(buf
, remaining
, "ipv4 %s %pI4 %d\n",
204 &inet_sk(sk
)->inet_rcv_saddr
,
205 inet_sk(sk
)->inet_num
);
207 #if IS_ENABLED(CONFIG_IPV6)
209 len
= snprintf(buf
, remaining
, "ipv6 %s %pI6 %d\n",
211 &sk
->sk_v6_rcv_saddr
,
212 inet_sk(sk
)->inet_num
);
216 len
= snprintf(buf
, remaining
, "*unknown-%d*\n",
220 if (len
>= remaining
) {
222 return -ENAMETOOLONG
;
227 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
228 static void svc_flush_bvec(const struct bio_vec
*bvec
, size_t size
, size_t seek
)
230 struct bvec_iter bi
= {
231 .bi_size
= size
+ seek
,
235 bvec_iter_advance(bvec
, &bi
, seek
& PAGE_MASK
);
236 for_each_bvec(bv
, bvec
, bi
, bi
)
237 flush_dcache_page(bv
.bv_page
);
240 static inline void svc_flush_bvec(const struct bio_vec
*bvec
, size_t size
,
247 * Read from @rqstp's transport socket. The incoming message fills whole
248 * pages in @rqstp's rq_pages array until the last page of the message
249 * has been received into a partial page.
251 static ssize_t
svc_tcp_read_msg(struct svc_rqst
*rqstp
, size_t buflen
,
254 struct svc_sock
*svsk
=
255 container_of(rqstp
->rq_xprt
, struct svc_sock
, sk_xprt
);
256 struct bio_vec
*bvec
= rqstp
->rq_bvec
;
257 struct msghdr msg
= { NULL
};
262 rqstp
->rq_xprt_hlen
= 0;
264 clear_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
);
266 for (i
= 0, t
= 0; t
< buflen
; i
++, t
+= PAGE_SIZE
) {
267 bvec
[i
].bv_page
= rqstp
->rq_pages
[i
];
268 bvec
[i
].bv_len
= PAGE_SIZE
;
269 bvec
[i
].bv_offset
= 0;
271 rqstp
->rq_respages
= &rqstp
->rq_pages
[i
];
272 rqstp
->rq_next_page
= rqstp
->rq_respages
+ 1;
274 iov_iter_bvec(&msg
.msg_iter
, READ
, bvec
, i
, buflen
);
276 iov_iter_advance(&msg
.msg_iter
, seek
);
279 len
= sock_recvmsg(svsk
->sk_sock
, &msg
, MSG_DONTWAIT
);
281 svc_flush_bvec(bvec
, len
, seek
);
283 /* If we read a full record, then assume there may be more
284 * data to read (stream based sockets only!)
287 set_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
);
293 * Set socket snd and rcv buffer lengths
295 static void svc_sock_setbufsize(struct svc_sock
*svsk
, unsigned int nreqs
)
297 unsigned int max_mesg
= svsk
->sk_xprt
.xpt_server
->sv_max_mesg
;
298 struct socket
*sock
= svsk
->sk_sock
;
300 nreqs
= min(nreqs
, INT_MAX
/ 2 / max_mesg
);
303 sock
->sk
->sk_sndbuf
= nreqs
* max_mesg
* 2;
304 sock
->sk
->sk_rcvbuf
= nreqs
* max_mesg
* 2;
305 sock
->sk
->sk_write_space(sock
->sk
);
306 release_sock(sock
->sk
);
309 static void svc_sock_secure_port(struct svc_rqst
*rqstp
)
311 if (svc_port_is_privileged(svc_addr(rqstp
)))
312 set_bit(RQ_SECURE
, &rqstp
->rq_flags
);
314 clear_bit(RQ_SECURE
, &rqstp
->rq_flags
);
318 * INET callback when data has been received on the socket.
320 static void svc_data_ready(struct sock
*sk
)
322 struct svc_sock
*svsk
= (struct svc_sock
*)sk
->sk_user_data
;
325 /* Refer to svc_setup_socket() for details. */
328 trace_svcsock_data_ready(&svsk
->sk_xprt
, 0);
329 if (!test_and_set_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
))
330 svc_xprt_enqueue(&svsk
->sk_xprt
);
335 * INET callback when space is newly available on the socket.
337 static void svc_write_space(struct sock
*sk
)
339 struct svc_sock
*svsk
= (struct svc_sock
*)(sk
->sk_user_data
);
342 /* Refer to svc_setup_socket() for details. */
344 trace_svcsock_write_space(&svsk
->sk_xprt
, 0);
345 svsk
->sk_owspace(sk
);
346 svc_xprt_enqueue(&svsk
->sk_xprt
);
350 static int svc_tcp_has_wspace(struct svc_xprt
*xprt
)
352 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
354 if (test_bit(XPT_LISTENER
, &xprt
->xpt_flags
))
356 return !test_bit(SOCK_NOSPACE
, &svsk
->sk_sock
->flags
);
359 static void svc_tcp_kill_temp_xprt(struct svc_xprt
*xprt
)
361 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
363 sock_no_linger(svsk
->sk_sock
->sk
);
367 * See net/ipv6/ip_sockglue.c : ip_cmsg_recv_pktinfo
369 static int svc_udp_get_dest_address4(struct svc_rqst
*rqstp
,
372 struct in_pktinfo
*pki
= CMSG_DATA(cmh
);
373 struct sockaddr_in
*daddr
= svc_daddr_in(rqstp
);
375 if (cmh
->cmsg_type
!= IP_PKTINFO
)
378 daddr
->sin_family
= AF_INET
;
379 daddr
->sin_addr
.s_addr
= pki
->ipi_spec_dst
.s_addr
;
384 * See net/ipv6/datagram.c : ip6_datagram_recv_ctl
386 static int svc_udp_get_dest_address6(struct svc_rqst
*rqstp
,
389 struct in6_pktinfo
*pki
= CMSG_DATA(cmh
);
390 struct sockaddr_in6
*daddr
= svc_daddr_in6(rqstp
);
392 if (cmh
->cmsg_type
!= IPV6_PKTINFO
)
395 daddr
->sin6_family
= AF_INET6
;
396 daddr
->sin6_addr
= pki
->ipi6_addr
;
397 daddr
->sin6_scope_id
= pki
->ipi6_ifindex
;
402 * Copy the UDP datagram's destination address to the rqstp structure.
403 * The 'destination' address in this case is the address to which the
404 * peer sent the datagram, i.e. our local address. For multihomed
405 * hosts, this can change from msg to msg. Note that only the IP
406 * address changes, the port number should remain the same.
408 static int svc_udp_get_dest_address(struct svc_rqst
*rqstp
,
411 switch (cmh
->cmsg_level
) {
413 return svc_udp_get_dest_address4(rqstp
, cmh
);
415 return svc_udp_get_dest_address6(rqstp
, cmh
);
422 * svc_udp_recvfrom - Receive a datagram from a UDP socket.
423 * @rqstp: request structure into which to receive an RPC Call
425 * Called in a loop when XPT_DATA has been set.
428 * On success, the number of bytes in a received RPC Call, or
429 * %0 if a complete RPC Call message was not ready to return
431 static int svc_udp_recvfrom(struct svc_rqst
*rqstp
)
433 struct svc_sock
*svsk
=
434 container_of(rqstp
->rq_xprt
, struct svc_sock
, sk_xprt
);
435 struct svc_serv
*serv
= svsk
->sk_xprt
.xpt_server
;
439 long all
[SVC_PKTINFO_SPACE
/ sizeof(long)];
441 struct cmsghdr
*cmh
= &buffer
.hdr
;
442 struct msghdr msg
= {
443 .msg_name
= svc_addr(rqstp
),
445 .msg_controllen
= sizeof(buffer
),
446 .msg_flags
= MSG_DONTWAIT
,
451 if (test_and_clear_bit(XPT_CHNGBUF
, &svsk
->sk_xprt
.xpt_flags
))
452 /* udp sockets need large rcvbuf as all pending
453 * requests are still in that buffer. sndbuf must
454 * also be large enough that there is enough space
455 * for one reply per thread. We count all threads
456 * rather than threads in a particular pool, which
457 * provides an upper bound on the number of threads
458 * which will access the socket.
460 svc_sock_setbufsize(svsk
, serv
->sv_nrthreads
+ 3);
462 clear_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
);
463 err
= kernel_recvmsg(svsk
->sk_sock
, &msg
, NULL
,
464 0, 0, MSG_PEEK
| MSG_DONTWAIT
);
467 skb
= skb_recv_udp(svsk
->sk_sk
, 0, 1, &err
);
471 len
= svc_addr_len(svc_addr(rqstp
));
472 rqstp
->rq_addrlen
= len
;
473 if (skb
->tstamp
== 0) {
474 skb
->tstamp
= ktime_get_real();
475 /* Don't enable netstamp, sunrpc doesn't
476 need that much accuracy */
478 sock_write_timestamp(svsk
->sk_sk
, skb
->tstamp
);
479 set_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
); /* there may be more data... */
482 rqstp
->rq_arg
.len
= len
;
483 trace_svcsock_udp_recv(&svsk
->sk_xprt
, len
);
485 rqstp
->rq_prot
= IPPROTO_UDP
;
487 if (!svc_udp_get_dest_address(rqstp
, cmh
))
489 rqstp
->rq_daddrlen
= svc_addr_len(svc_daddr(rqstp
));
491 if (skb_is_nonlinear(skb
)) {
492 /* we have to copy */
494 if (csum_partial_copy_to_xdr(&rqstp
->rq_arg
, skb
))
499 /* we can use it in-place */
500 rqstp
->rq_arg
.head
[0].iov_base
= skb
->data
;
501 rqstp
->rq_arg
.head
[0].iov_len
= len
;
502 if (skb_checksum_complete(skb
))
504 rqstp
->rq_xprt_ctxt
= skb
;
507 rqstp
->rq_arg
.page_base
= 0;
508 if (len
<= rqstp
->rq_arg
.head
[0].iov_len
) {
509 rqstp
->rq_arg
.head
[0].iov_len
= len
;
510 rqstp
->rq_arg
.page_len
= 0;
511 rqstp
->rq_respages
= rqstp
->rq_pages
+1;
513 rqstp
->rq_arg
.page_len
= len
- rqstp
->rq_arg
.head
[0].iov_len
;
514 rqstp
->rq_respages
= rqstp
->rq_pages
+ 1 +
515 DIV_ROUND_UP(rqstp
->rq_arg
.page_len
, PAGE_SIZE
);
517 rqstp
->rq_next_page
= rqstp
->rq_respages
+1;
520 serv
->sv_stats
->netudpcnt
++;
522 svc_xprt_received(rqstp
->rq_xprt
);
526 if (err
!= -EAGAIN
) {
527 /* possibly an icmp error */
528 set_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
);
530 trace_svcsock_udp_recv_err(&svsk
->sk_xprt
, err
);
533 net_warn_ratelimited("svc: received unknown control message %d/%d; dropping RPC reply datagram\n",
534 cmh
->cmsg_level
, cmh
->cmsg_type
);
541 svc_xprt_received(rqstp
->rq_xprt
);
546 * svc_udp_sendto - Send out a reply on a UDP socket
547 * @rqstp: completed svc_rqst
549 * xpt_mutex ensures @rqstp's whole message is written to the socket
550 * without interruption.
552 * Returns the number of bytes sent, or a negative errno.
554 static int svc_udp_sendto(struct svc_rqst
*rqstp
)
556 struct svc_xprt
*xprt
= rqstp
->rq_xprt
;
557 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
558 struct xdr_buf
*xdr
= &rqstp
->rq_res
;
561 long all
[SVC_PKTINFO_SPACE
/ sizeof(long)];
563 struct cmsghdr
*cmh
= &buffer
.hdr
;
564 struct msghdr msg
= {
565 .msg_name
= &rqstp
->rq_addr
,
566 .msg_namelen
= rqstp
->rq_addrlen
,
568 .msg_controllen
= sizeof(buffer
),
573 svc_udp_release_rqst(rqstp
);
575 svc_set_cmsg_data(rqstp
, cmh
);
577 mutex_lock(&xprt
->xpt_mutex
);
579 if (svc_xprt_is_dead(xprt
))
582 err
= xprt_sock_sendmsg(svsk
->sk_sock
, &msg
, xdr
, 0, 0, &sent
);
584 if (err
== -ECONNREFUSED
) {
585 /* ICMP error on earlier request. */
586 err
= xprt_sock_sendmsg(svsk
->sk_sock
, &msg
, xdr
, 0, 0, &sent
);
589 trace_svcsock_udp_send(xprt
, err
);
591 mutex_unlock(&xprt
->xpt_mutex
);
597 mutex_unlock(&xprt
->xpt_mutex
);
601 static int svc_udp_has_wspace(struct svc_xprt
*xprt
)
603 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
604 struct svc_serv
*serv
= xprt
->xpt_server
;
605 unsigned long required
;
608 * Set the SOCK_NOSPACE flag before checking the available
611 set_bit(SOCK_NOSPACE
, &svsk
->sk_sock
->flags
);
612 required
= atomic_read(&svsk
->sk_xprt
.xpt_reserved
) + serv
->sv_max_mesg
;
613 if (required
*2 > sock_wspace(svsk
->sk_sk
))
615 clear_bit(SOCK_NOSPACE
, &svsk
->sk_sock
->flags
);
619 static struct svc_xprt
*svc_udp_accept(struct svc_xprt
*xprt
)
625 static void svc_udp_kill_temp_xprt(struct svc_xprt
*xprt
)
629 static struct svc_xprt
*svc_udp_create(struct svc_serv
*serv
,
631 struct sockaddr
*sa
, int salen
,
634 return svc_create_socket(serv
, IPPROTO_UDP
, net
, sa
, salen
, flags
);
637 static const struct svc_xprt_ops svc_udp_ops
= {
638 .xpo_create
= svc_udp_create
,
639 .xpo_recvfrom
= svc_udp_recvfrom
,
640 .xpo_sendto
= svc_udp_sendto
,
641 .xpo_result_payload
= svc_sock_result_payload
,
642 .xpo_release_rqst
= svc_udp_release_rqst
,
643 .xpo_detach
= svc_sock_detach
,
644 .xpo_free
= svc_sock_free
,
645 .xpo_has_wspace
= svc_udp_has_wspace
,
646 .xpo_accept
= svc_udp_accept
,
647 .xpo_secure_port
= svc_sock_secure_port
,
648 .xpo_kill_temp_xprt
= svc_udp_kill_temp_xprt
,
651 static struct svc_xprt_class svc_udp_class
= {
653 .xcl_owner
= THIS_MODULE
,
654 .xcl_ops
= &svc_udp_ops
,
655 .xcl_max_payload
= RPCSVC_MAXPAYLOAD_UDP
,
656 .xcl_ident
= XPRT_TRANSPORT_UDP
,
659 static void svc_udp_init(struct svc_sock
*svsk
, struct svc_serv
*serv
)
661 svc_xprt_init(sock_net(svsk
->sk_sock
->sk
), &svc_udp_class
,
662 &svsk
->sk_xprt
, serv
);
663 clear_bit(XPT_CACHE_AUTH
, &svsk
->sk_xprt
.xpt_flags
);
664 svsk
->sk_sk
->sk_data_ready
= svc_data_ready
;
665 svsk
->sk_sk
->sk_write_space
= svc_write_space
;
667 /* initialise setting must have enough space to
668 * receive and respond to one request.
669 * svc_udp_recvfrom will re-adjust if necessary
671 svc_sock_setbufsize(svsk
, 3);
673 /* data might have come in before data_ready set up */
674 set_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
);
675 set_bit(XPT_CHNGBUF
, &svsk
->sk_xprt
.xpt_flags
);
677 /* make sure we get destination address info */
678 switch (svsk
->sk_sk
->sk_family
) {
680 ip_sock_set_pktinfo(svsk
->sk_sock
->sk
);
683 ip6_sock_set_recvpktinfo(svsk
->sk_sock
->sk
);
691 * A data_ready event on a listening socket means there's a connection
692 * pending. Do not use state_change as a substitute for it.
694 static void svc_tcp_listen_data_ready(struct sock
*sk
)
696 struct svc_sock
*svsk
= (struct svc_sock
*)sk
->sk_user_data
;
699 /* Refer to svc_setup_socket() for details. */
705 * This callback may called twice when a new connection
706 * is established as a child socket inherits everything
707 * from a parent LISTEN socket.
708 * 1) data_ready method of the parent socket will be called
709 * when one of child sockets become ESTABLISHED.
710 * 2) data_ready method of the child socket may be called
711 * when it receives data before the socket is accepted.
712 * In case of 2, we should ignore it silently.
714 if (sk
->sk_state
== TCP_LISTEN
) {
716 set_bit(XPT_CONN
, &svsk
->sk_xprt
.xpt_flags
);
717 svc_xprt_enqueue(&svsk
->sk_xprt
);
723 * A state change on a connected socket means it's dying or dead.
725 static void svc_tcp_state_change(struct sock
*sk
)
727 struct svc_sock
*svsk
= (struct svc_sock
*)sk
->sk_user_data
;
730 /* Refer to svc_setup_socket() for details. */
733 trace_svcsock_tcp_state(&svsk
->sk_xprt
, svsk
->sk_sock
);
734 if (sk
->sk_state
!= TCP_ESTABLISHED
)
735 svc_xprt_deferred_close(&svsk
->sk_xprt
);
740 * Accept a TCP connection
742 static struct svc_xprt
*svc_tcp_accept(struct svc_xprt
*xprt
)
744 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
745 struct sockaddr_storage addr
;
746 struct sockaddr
*sin
= (struct sockaddr
*) &addr
;
747 struct svc_serv
*serv
= svsk
->sk_xprt
.xpt_server
;
748 struct socket
*sock
= svsk
->sk_sock
;
749 struct socket
*newsock
;
750 struct svc_sock
*newsvsk
;
756 clear_bit(XPT_CONN
, &svsk
->sk_xprt
.xpt_flags
);
757 err
= kernel_accept(sock
, &newsock
, O_NONBLOCK
);
760 printk(KERN_WARNING
"%s: no more sockets!\n",
762 else if (err
!= -EAGAIN
)
763 net_warn_ratelimited("%s: accept failed (err %d)!\n",
764 serv
->sv_name
, -err
);
765 trace_svcsock_accept_err(xprt
, serv
->sv_name
, err
);
768 set_bit(XPT_CONN
, &svsk
->sk_xprt
.xpt_flags
);
770 err
= kernel_getpeername(newsock
, sin
);
772 trace_svcsock_getpeername_err(xprt
, serv
->sv_name
, err
);
773 goto failed
; /* aborted connection or whatever */
777 /* Reset the inherited callbacks before calling svc_setup_socket */
778 newsock
->sk
->sk_state_change
= svsk
->sk_ostate
;
779 newsock
->sk
->sk_data_ready
= svsk
->sk_odata
;
780 newsock
->sk
->sk_write_space
= svsk
->sk_owspace
;
782 /* make sure that a write doesn't block forever when
785 newsock
->sk
->sk_sndtimeo
= HZ
*30;
787 newsvsk
= svc_setup_socket(serv
, newsock
,
788 (SVC_SOCK_ANONYMOUS
| SVC_SOCK_TEMPORARY
));
791 svc_xprt_set_remote(&newsvsk
->sk_xprt
, sin
, slen
);
792 err
= kernel_getsockname(newsock
, sin
);
794 if (unlikely(err
< 0))
795 slen
= offsetof(struct sockaddr
, sa_data
);
796 svc_xprt_set_local(&newsvsk
->sk_xprt
, sin
, slen
);
798 if (sock_is_loopback(newsock
->sk
))
799 set_bit(XPT_LOCAL
, &newsvsk
->sk_xprt
.xpt_flags
);
801 clear_bit(XPT_LOCAL
, &newsvsk
->sk_xprt
.xpt_flags
);
803 serv
->sv_stats
->nettcpconn
++;
805 return &newsvsk
->sk_xprt
;
808 sock_release(newsock
);
812 static size_t svc_tcp_restore_pages(struct svc_sock
*svsk
,
813 struct svc_rqst
*rqstp
)
815 size_t len
= svsk
->sk_datalen
;
816 unsigned int i
, npages
;
820 npages
= (len
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
821 for (i
= 0; i
< npages
; i
++) {
822 if (rqstp
->rq_pages
[i
] != NULL
)
823 put_page(rqstp
->rq_pages
[i
]);
824 BUG_ON(svsk
->sk_pages
[i
] == NULL
);
825 rqstp
->rq_pages
[i
] = svsk
->sk_pages
[i
];
826 svsk
->sk_pages
[i
] = NULL
;
828 rqstp
->rq_arg
.head
[0].iov_base
= page_address(rqstp
->rq_pages
[0]);
832 static void svc_tcp_save_pages(struct svc_sock
*svsk
, struct svc_rqst
*rqstp
)
834 unsigned int i
, len
, npages
;
836 if (svsk
->sk_datalen
== 0)
838 len
= svsk
->sk_datalen
;
839 npages
= (len
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
840 for (i
= 0; i
< npages
; i
++) {
841 svsk
->sk_pages
[i
] = rqstp
->rq_pages
[i
];
842 rqstp
->rq_pages
[i
] = NULL
;
846 static void svc_tcp_clear_pages(struct svc_sock
*svsk
)
848 unsigned int i
, len
, npages
;
850 if (svsk
->sk_datalen
== 0)
852 len
= svsk
->sk_datalen
;
853 npages
= (len
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
854 for (i
= 0; i
< npages
; i
++) {
855 if (svsk
->sk_pages
[i
] == NULL
) {
859 put_page(svsk
->sk_pages
[i
]);
860 svsk
->sk_pages
[i
] = NULL
;
864 svsk
->sk_datalen
= 0;
868 * Receive fragment record header into sk_marker.
870 static ssize_t
svc_tcp_read_marker(struct svc_sock
*svsk
,
871 struct svc_rqst
*rqstp
)
875 /* If we haven't gotten the record length yet,
876 * get the next four bytes.
878 if (svsk
->sk_tcplen
< sizeof(rpc_fraghdr
)) {
879 struct msghdr msg
= { NULL
};
882 want
= sizeof(rpc_fraghdr
) - svsk
->sk_tcplen
;
883 iov
.iov_base
= ((char *)&svsk
->sk_marker
) + svsk
->sk_tcplen
;
885 iov_iter_kvec(&msg
.msg_iter
, READ
, &iov
, 1, want
);
886 len
= sock_recvmsg(svsk
->sk_sock
, &msg
, MSG_DONTWAIT
);
889 svsk
->sk_tcplen
+= len
;
891 /* call again to read the remaining bytes */
894 trace_svcsock_marker(&svsk
->sk_xprt
, svsk
->sk_marker
);
895 if (svc_sock_reclen(svsk
) + svsk
->sk_datalen
>
896 svsk
->sk_xprt
.xpt_server
->sv_max_mesg
)
899 return svc_sock_reclen(svsk
);
902 net_notice_ratelimited("svc: %s %s RPC fragment too large: %d\n",
903 __func__
, svsk
->sk_xprt
.xpt_server
->sv_name
,
904 svc_sock_reclen(svsk
));
905 svc_xprt_deferred_close(&svsk
->sk_xprt
);
910 static int receive_cb_reply(struct svc_sock
*svsk
, struct svc_rqst
*rqstp
)
912 struct rpc_xprt
*bc_xprt
= svsk
->sk_xprt
.xpt_bc_xprt
;
913 struct rpc_rqst
*req
= NULL
;
914 struct kvec
*src
, *dst
;
915 __be32
*p
= (__be32
*)rqstp
->rq_arg
.head
[0].iov_base
;
924 spin_lock(&bc_xprt
->queue_lock
);
925 req
= xprt_lookup_rqst(bc_xprt
, xid
);
927 goto unlock_notfound
;
929 memcpy(&req
->rq_private_buf
, &req
->rq_rcv_buf
, sizeof(struct xdr_buf
));
931 * XXX!: cheating for now! Only copying HEAD.
932 * But we know this is good enough for now (in fact, for any
933 * callback reply in the forseeable future).
935 dst
= &req
->rq_private_buf
.head
[0];
936 src
= &rqstp
->rq_arg
.head
[0];
937 if (dst
->iov_len
< src
->iov_len
)
938 goto unlock_eagain
; /* whatever; just giving up. */
939 memcpy(dst
->iov_base
, src
->iov_base
, src
->iov_len
);
940 xprt_complete_rqst(req
->rq_task
, rqstp
->rq_arg
.len
);
941 rqstp
->rq_arg
.len
= 0;
942 spin_unlock(&bc_xprt
->queue_lock
);
946 "%s: Got unrecognized reply: "
947 "calldir 0x%x xpt_bc_xprt %p xid %08x\n",
948 __func__
, ntohl(calldir
),
949 bc_xprt
, ntohl(xid
));
951 spin_unlock(&bc_xprt
->queue_lock
);
955 static void svc_tcp_fragment_received(struct svc_sock
*svsk
)
957 /* If we have more data, signal svc_xprt_enqueue() to try again */
959 svsk
->sk_marker
= xdr_zero
;
963 * svc_tcp_recvfrom - Receive data from a TCP socket
964 * @rqstp: request structure into which to receive an RPC Call
966 * Called in a loop when XPT_DATA has been set.
968 * Read the 4-byte stream record marker, then use the record length
969 * in that marker to set up exactly the resources needed to receive
970 * the next RPC message into @rqstp.
973 * On success, the number of bytes in a received RPC Call, or
974 * %0 if a complete RPC Call message was not ready to return
976 * The zero return case handles partial receives and callback Replies.
977 * The state of a partial receive is preserved in the svc_sock for
978 * the next call to svc_tcp_recvfrom.
980 static int svc_tcp_recvfrom(struct svc_rqst
*rqstp
)
982 struct svc_sock
*svsk
=
983 container_of(rqstp
->rq_xprt
, struct svc_sock
, sk_xprt
);
984 struct svc_serv
*serv
= svsk
->sk_xprt
.xpt_server
;
990 clear_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
);
991 len
= svc_tcp_read_marker(svsk
, rqstp
);
995 base
= svc_tcp_restore_pages(svsk
, rqstp
);
996 want
= len
- (svsk
->sk_tcplen
- sizeof(rpc_fraghdr
));
997 len
= svc_tcp_read_msg(rqstp
, base
+ want
, base
);
999 trace_svcsock_tcp_recv(&svsk
->sk_xprt
, len
);
1000 svsk
->sk_tcplen
+= len
;
1001 svsk
->sk_datalen
+= len
;
1003 if (len
!= want
|| !svc_sock_final_rec(svsk
))
1004 goto err_incomplete
;
1005 if (svsk
->sk_datalen
< 8)
1008 rqstp
->rq_arg
.len
= svsk
->sk_datalen
;
1009 rqstp
->rq_arg
.page_base
= 0;
1010 if (rqstp
->rq_arg
.len
<= rqstp
->rq_arg
.head
[0].iov_len
) {
1011 rqstp
->rq_arg
.head
[0].iov_len
= rqstp
->rq_arg
.len
;
1012 rqstp
->rq_arg
.page_len
= 0;
1014 rqstp
->rq_arg
.page_len
= rqstp
->rq_arg
.len
- rqstp
->rq_arg
.head
[0].iov_len
;
1016 rqstp
->rq_xprt_ctxt
= NULL
;
1017 rqstp
->rq_prot
= IPPROTO_TCP
;
1018 if (test_bit(XPT_LOCAL
, &svsk
->sk_xprt
.xpt_flags
))
1019 set_bit(RQ_LOCAL
, &rqstp
->rq_flags
);
1021 clear_bit(RQ_LOCAL
, &rqstp
->rq_flags
);
1023 p
= (__be32
*)rqstp
->rq_arg
.head
[0].iov_base
;
1026 len
= receive_cb_reply(svsk
, rqstp
);
1028 /* Reset TCP read info */
1029 svsk
->sk_datalen
= 0;
1030 svc_tcp_fragment_received(svsk
);
1035 svc_xprt_copy_addrs(rqstp
, &svsk
->sk_xprt
);
1037 serv
->sv_stats
->nettcpcnt
++;
1039 svc_xprt_received(rqstp
->rq_xprt
);
1040 return rqstp
->rq_arg
.len
;
1043 svc_tcp_save_pages(svsk
, rqstp
);
1044 if (len
< 0 && len
!= -EAGAIN
)
1047 svc_tcp_fragment_received(svsk
);
1049 trace_svcsock_tcp_recv_short(&svsk
->sk_xprt
,
1050 svc_sock_reclen(svsk
),
1051 svsk
->sk_tcplen
- sizeof(rpc_fraghdr
));
1056 trace_svcsock_tcp_recv_eagain(&svsk
->sk_xprt
, 0);
1059 svsk
->sk_datalen
= 0;
1061 trace_svcsock_tcp_recv_err(&svsk
->sk_xprt
, len
);
1062 svc_xprt_deferred_close(&svsk
->sk_xprt
);
1064 svc_xprt_received(rqstp
->rq_xprt
);
1065 return 0; /* record not complete */
1068 static int svc_tcp_send_kvec(struct socket
*sock
, const struct kvec
*vec
,
1071 return kernel_sendpage(sock
, virt_to_page(vec
->iov_base
),
1072 offset_in_page(vec
->iov_base
),
1073 vec
->iov_len
, flags
);
1077 * kernel_sendpage() is used exclusively to reduce the number of
1078 * copy operations in this path. Therefore the caller must ensure
1079 * that the pages backing @xdr are unchanging.
1081 * In addition, the logic assumes that * .bv_len is never larger
1084 static int svc_tcp_sendmsg(struct socket
*sock
, struct xdr_buf
*xdr
,
1085 rpc_fraghdr marker
, unsigned int *sentp
)
1087 const struct kvec
*head
= xdr
->head
;
1088 const struct kvec
*tail
= xdr
->tail
;
1090 .iov_base
= &marker
,
1091 .iov_len
= sizeof(marker
),
1093 struct msghdr msg
= {
1099 xdr_alloc_bvec(xdr
, GFP_KERNEL
);
1101 ret
= kernel_sendmsg(sock
, &msg
, &rm
, 1, rm
.iov_len
);
1105 if (ret
!= rm
.iov_len
)
1108 ret
= svc_tcp_send_kvec(sock
, head
, 0);
1112 if (ret
!= head
->iov_len
)
1115 if (xdr
->page_len
) {
1116 unsigned int offset
, len
, remaining
;
1117 struct bio_vec
*bvec
;
1119 bvec
= xdr
->bvec
+ (xdr
->page_base
>> PAGE_SHIFT
);
1120 offset
= offset_in_page(xdr
->page_base
);
1121 remaining
= xdr
->page_len
;
1122 while (remaining
> 0) {
1123 len
= min(remaining
, bvec
->bv_len
- offset
);
1124 ret
= kernel_sendpage(sock
, bvec
->bv_page
,
1125 bvec
->bv_offset
+ offset
,
1138 if (tail
->iov_len
) {
1139 ret
= svc_tcp_send_kvec(sock
, tail
, 0);
1150 * svc_tcp_sendto - Send out a reply on a TCP socket
1151 * @rqstp: completed svc_rqst
1153 * xpt_mutex ensures @rqstp's whole message is written to the socket
1154 * without interruption.
1156 * Returns the number of bytes sent, or a negative errno.
1158 static int svc_tcp_sendto(struct svc_rqst
*rqstp
)
1160 struct svc_xprt
*xprt
= rqstp
->rq_xprt
;
1161 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
1162 struct xdr_buf
*xdr
= &rqstp
->rq_res
;
1163 rpc_fraghdr marker
= cpu_to_be32(RPC_LAST_STREAM_FRAGMENT
|
1168 svc_tcp_release_rqst(rqstp
);
1170 atomic_inc(&svsk
->sk_sendqlen
);
1171 mutex_lock(&xprt
->xpt_mutex
);
1172 if (svc_xprt_is_dead(xprt
))
1174 tcp_sock_set_cork(svsk
->sk_sk
, true);
1175 err
= svc_tcp_sendmsg(svsk
->sk_sock
, xdr
, marker
, &sent
);
1177 trace_svcsock_tcp_send(xprt
, err
< 0 ? (long)err
: sent
);
1178 if (err
< 0 || sent
!= (xdr
->len
+ sizeof(marker
)))
1180 if (atomic_dec_and_test(&svsk
->sk_sendqlen
))
1181 tcp_sock_set_cork(svsk
->sk_sk
, false);
1182 mutex_unlock(&xprt
->xpt_mutex
);
1186 atomic_dec(&svsk
->sk_sendqlen
);
1187 mutex_unlock(&xprt
->xpt_mutex
);
1190 pr_notice("rpc-srv/tcp: %s: %s %d when sending %d bytes - shutting down socket\n",
1191 xprt
->xpt_server
->sv_name
,
1192 (err
< 0) ? "got error" : "sent",
1193 (err
< 0) ? err
: sent
, xdr
->len
);
1194 svc_xprt_deferred_close(xprt
);
1195 atomic_dec(&svsk
->sk_sendqlen
);
1196 mutex_unlock(&xprt
->xpt_mutex
);
1200 static struct svc_xprt
*svc_tcp_create(struct svc_serv
*serv
,
1202 struct sockaddr
*sa
, int salen
,
1205 return svc_create_socket(serv
, IPPROTO_TCP
, net
, sa
, salen
, flags
);
1208 static const struct svc_xprt_ops svc_tcp_ops
= {
1209 .xpo_create
= svc_tcp_create
,
1210 .xpo_recvfrom
= svc_tcp_recvfrom
,
1211 .xpo_sendto
= svc_tcp_sendto
,
1212 .xpo_result_payload
= svc_sock_result_payload
,
1213 .xpo_release_rqst
= svc_tcp_release_rqst
,
1214 .xpo_detach
= svc_tcp_sock_detach
,
1215 .xpo_free
= svc_sock_free
,
1216 .xpo_has_wspace
= svc_tcp_has_wspace
,
1217 .xpo_accept
= svc_tcp_accept
,
1218 .xpo_secure_port
= svc_sock_secure_port
,
1219 .xpo_kill_temp_xprt
= svc_tcp_kill_temp_xprt
,
1222 static struct svc_xprt_class svc_tcp_class
= {
1224 .xcl_owner
= THIS_MODULE
,
1225 .xcl_ops
= &svc_tcp_ops
,
1226 .xcl_max_payload
= RPCSVC_MAXPAYLOAD_TCP
,
1227 .xcl_ident
= XPRT_TRANSPORT_TCP
,
1230 void svc_init_xprt_sock(void)
1232 svc_reg_xprt_class(&svc_tcp_class
);
1233 svc_reg_xprt_class(&svc_udp_class
);
1236 void svc_cleanup_xprt_sock(void)
1238 svc_unreg_xprt_class(&svc_tcp_class
);
1239 svc_unreg_xprt_class(&svc_udp_class
);
1242 static void svc_tcp_init(struct svc_sock
*svsk
, struct svc_serv
*serv
)
1244 struct sock
*sk
= svsk
->sk_sk
;
1246 svc_xprt_init(sock_net(svsk
->sk_sock
->sk
), &svc_tcp_class
,
1247 &svsk
->sk_xprt
, serv
);
1248 set_bit(XPT_CACHE_AUTH
, &svsk
->sk_xprt
.xpt_flags
);
1249 set_bit(XPT_CONG_CTRL
, &svsk
->sk_xprt
.xpt_flags
);
1250 if (sk
->sk_state
== TCP_LISTEN
) {
1251 strcpy(svsk
->sk_xprt
.xpt_remotebuf
, "listener");
1252 set_bit(XPT_LISTENER
, &svsk
->sk_xprt
.xpt_flags
);
1253 sk
->sk_data_ready
= svc_tcp_listen_data_ready
;
1254 set_bit(XPT_CONN
, &svsk
->sk_xprt
.xpt_flags
);
1256 sk
->sk_state_change
= svc_tcp_state_change
;
1257 sk
->sk_data_ready
= svc_data_ready
;
1258 sk
->sk_write_space
= svc_write_space
;
1260 svsk
->sk_marker
= xdr_zero
;
1261 svsk
->sk_tcplen
= 0;
1262 svsk
->sk_datalen
= 0;
1263 memset(&svsk
->sk_pages
[0], 0, sizeof(svsk
->sk_pages
));
1265 tcp_sock_set_nodelay(sk
);
1267 set_bit(XPT_DATA
, &svsk
->sk_xprt
.xpt_flags
);
1268 switch (sk
->sk_state
) {
1270 case TCP_ESTABLISHED
:
1273 svc_xprt_deferred_close(&svsk
->sk_xprt
);
1278 void svc_sock_update_bufs(struct svc_serv
*serv
)
1281 * The number of server threads has changed. Update
1282 * rcvbuf and sndbuf accordingly on all sockets
1284 struct svc_sock
*svsk
;
1286 spin_lock_bh(&serv
->sv_lock
);
1287 list_for_each_entry(svsk
, &serv
->sv_permsocks
, sk_xprt
.xpt_list
)
1288 set_bit(XPT_CHNGBUF
, &svsk
->sk_xprt
.xpt_flags
);
1289 spin_unlock_bh(&serv
->sv_lock
);
1291 EXPORT_SYMBOL_GPL(svc_sock_update_bufs
);
1294 * Initialize socket for RPC use and create svc_sock struct
1296 static struct svc_sock
*svc_setup_socket(struct svc_serv
*serv
,
1297 struct socket
*sock
,
1300 struct svc_sock
*svsk
;
1302 int pmap_register
= !(flags
& SVC_SOCK_ANONYMOUS
);
1305 svsk
= kzalloc(sizeof(*svsk
), GFP_KERNEL
);
1307 return ERR_PTR(-ENOMEM
);
1311 /* Register socket with portmapper */
1313 err
= svc_register(serv
, sock_net(sock
->sk
), inet
->sk_family
,
1315 ntohs(inet_sk(inet
)->inet_sport
));
1319 return ERR_PTR(err
);
1322 svsk
->sk_sock
= sock
;
1324 svsk
->sk_ostate
= inet
->sk_state_change
;
1325 svsk
->sk_odata
= inet
->sk_data_ready
;
1326 svsk
->sk_owspace
= inet
->sk_write_space
;
1328 * This barrier is necessary in order to prevent race condition
1329 * with svc_data_ready(), svc_listen_data_ready() and others
1330 * when calling callbacks above.
1333 inet
->sk_user_data
= svsk
;
1335 /* Initialize the socket */
1336 if (sock
->type
== SOCK_DGRAM
)
1337 svc_udp_init(svsk
, serv
);
1339 svc_tcp_init(svsk
, serv
);
1341 trace_svcsock_new_socket(sock
);
1345 bool svc_alien_sock(struct net
*net
, int fd
)
1348 struct socket
*sock
= sockfd_lookup(fd
, &err
);
1353 if (sock_net(sock
->sk
) != net
)
1359 EXPORT_SYMBOL_GPL(svc_alien_sock
);
1362 * svc_addsock - add a listener socket to an RPC service
1363 * @serv: pointer to RPC service to which to add a new listener
1364 * @fd: file descriptor of the new listener
1365 * @name_return: pointer to buffer to fill in with name of listener
1366 * @len: size of the buffer
1369 * Fills in socket name and returns positive length of name if successful.
1370 * Name is terminated with '\n'. On error, returns a negative errno
1373 int svc_addsock(struct svc_serv
*serv
, const int fd
, char *name_return
,
1374 const size_t len
, const struct cred
*cred
)
1377 struct socket
*so
= sockfd_lookup(fd
, &err
);
1378 struct svc_sock
*svsk
= NULL
;
1379 struct sockaddr_storage addr
;
1380 struct sockaddr
*sin
= (struct sockaddr
*)&addr
;
1385 err
= -EAFNOSUPPORT
;
1386 if ((so
->sk
->sk_family
!= PF_INET
) && (so
->sk
->sk_family
!= PF_INET6
))
1388 err
= -EPROTONOSUPPORT
;
1389 if (so
->sk
->sk_protocol
!= IPPROTO_TCP
&&
1390 so
->sk
->sk_protocol
!= IPPROTO_UDP
)
1393 if (so
->state
> SS_UNCONNECTED
)
1396 if (!try_module_get(THIS_MODULE
))
1398 svsk
= svc_setup_socket(serv
, so
, SVC_SOCK_DEFAULTS
);
1400 module_put(THIS_MODULE
);
1401 err
= PTR_ERR(svsk
);
1404 salen
= kernel_getsockname(svsk
->sk_sock
, sin
);
1406 svc_xprt_set_local(&svsk
->sk_xprt
, sin
, salen
);
1407 svsk
->sk_xprt
.xpt_cred
= get_cred(cred
);
1408 svc_add_new_perm_xprt(serv
, &svsk
->sk_xprt
);
1409 return svc_one_sock_name(svsk
, name_return
, len
);
1414 EXPORT_SYMBOL_GPL(svc_addsock
);
1417 * Create socket for RPC service.
1419 static struct svc_xprt
*svc_create_socket(struct svc_serv
*serv
,
1422 struct sockaddr
*sin
, int len
,
1425 struct svc_sock
*svsk
;
1426 struct socket
*sock
;
1429 struct sockaddr_storage addr
;
1430 struct sockaddr
*newsin
= (struct sockaddr
*)&addr
;
1434 if (protocol
!= IPPROTO_UDP
&& protocol
!= IPPROTO_TCP
) {
1435 printk(KERN_WARNING
"svc: only UDP and TCP "
1436 "sockets supported\n");
1437 return ERR_PTR(-EINVAL
);
1440 type
= (protocol
== IPPROTO_UDP
)? SOCK_DGRAM
: SOCK_STREAM
;
1441 switch (sin
->sa_family
) {
1449 return ERR_PTR(-EINVAL
);
1452 error
= __sock_create(net
, family
, type
, protocol
, &sock
, 1);
1454 return ERR_PTR(error
);
1456 svc_reclassify_socket(sock
);
1459 * If this is an PF_INET6 listener, we want to avoid
1460 * getting requests from IPv4 remotes. Those should
1461 * be shunted to a PF_INET listener via rpcbind.
1463 if (family
== PF_INET6
)
1464 ip6_sock_set_v6only(sock
->sk
);
1465 if (type
== SOCK_STREAM
)
1466 sock
->sk
->sk_reuse
= SK_CAN_REUSE
; /* allow address reuse */
1467 error
= kernel_bind(sock
, sin
, len
);
1471 error
= kernel_getsockname(sock
, newsin
);
1476 if (protocol
== IPPROTO_TCP
) {
1477 if ((error
= kernel_listen(sock
, 64)) < 0)
1481 svsk
= svc_setup_socket(serv
, sock
, flags
);
1483 error
= PTR_ERR(svsk
);
1486 svc_xprt_set_local(&svsk
->sk_xprt
, newsin
, newlen
);
1487 return (struct svc_xprt
*)svsk
;
1490 return ERR_PTR(error
);
1494 * Detach the svc_sock from the socket so that no
1495 * more callbacks occur.
1497 static void svc_sock_detach(struct svc_xprt
*xprt
)
1499 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
1500 struct sock
*sk
= svsk
->sk_sk
;
1502 /* put back the old socket callbacks */
1504 sk
->sk_state_change
= svsk
->sk_ostate
;
1505 sk
->sk_data_ready
= svsk
->sk_odata
;
1506 sk
->sk_write_space
= svsk
->sk_owspace
;
1507 sk
->sk_user_data
= NULL
;
1512 * Disconnect the socket, and reset the callbacks
1514 static void svc_tcp_sock_detach(struct svc_xprt
*xprt
)
1516 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
1518 svc_sock_detach(xprt
);
1520 if (!test_bit(XPT_LISTENER
, &xprt
->xpt_flags
)) {
1521 svc_tcp_clear_pages(svsk
);
1522 kernel_sock_shutdown(svsk
->sk_sock
, SHUT_RDWR
);
1527 * Free the svc_sock's socket resources and the svc_sock itself.
1529 static void svc_sock_free(struct svc_xprt
*xprt
)
1531 struct svc_sock
*svsk
= container_of(xprt
, struct svc_sock
, sk_xprt
);
1533 if (svsk
->sk_sock
->file
)
1534 sockfd_put(svsk
->sk_sock
);
1536 sock_release(svsk
->sk_sock
);