1 /* 2 * linux/net/sunrpc/svcsock.c 3 * 4 * These are the RPC server socket internals. 5 * 6 * The server scheduling algorithm does not always distribute the load 7 * evenly when servicing a single client. May need to modify the 8 * svc_xprt_enqueue procedure... 9 * 10 * TCP support is largely untested and may be a little slow. The problem 11 * is that we currently do two separate recvfrom's, one for the 4-byte 12 * record length, and the second for the actual record. This could possibly 13 * be improved by always reading a minimum size of around 100 bytes and 14 * tucking any superfluous bytes away in a temporary store. Still, that 15 * leaves write requests out in the rain. An alternative may be to peek at 16 * the first skb in the queue, and if it matches the next TCP sequence 17 * number, to extract the record marker. Yuck. 18 * 19 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> 20 */ 21 22 #include <linux/kernel.h> 23 #include <linux/sched.h> 24 #include <linux/errno.h> 25 #include <linux/fcntl.h> 26 #include <linux/net.h> 27 #include <linux/in.h> 28 #include <linux/inet.h> 29 #include <linux/udp.h> 30 #include <linux/tcp.h> 31 #include <linux/unistd.h> 32 #include <linux/slab.h> 33 #include <linux/netdevice.h> 34 #include <linux/skbuff.h> 35 #include <linux/file.h> 36 #include <linux/freezer.h> 37 #include <net/sock.h> 38 #include <net/checksum.h> 39 #include <net/ip.h> 40 #include <net/ipv6.h> 41 #include <net/tcp.h> 42 #include <net/tcp_states.h> 43 #include <asm/uaccess.h> 44 #include <asm/ioctls.h> 45 46 #include <linux/sunrpc/types.h> 47 #include <linux/sunrpc/clnt.h> 48 #include <linux/sunrpc/xdr.h> 49 #include <linux/sunrpc/msg_prot.h> 50 #include <linux/sunrpc/svcsock.h> 51 #include <linux/sunrpc/stats.h> 52 53 #define RPCDBG_FACILITY RPCDBG_SVCXPRT 54 55 56 static struct svc_sock *svc_setup_socket(struct svc_serv *, struct socket *, 57 int *errp, int flags); 58 static void svc_udp_data_ready(struct sock *, int); 59 static int svc_udp_recvfrom(struct svc_rqst *); 60 static int svc_udp_sendto(struct svc_rqst *); 61 static void svc_sock_detach(struct svc_xprt *); 62 static void svc_tcp_sock_detach(struct svc_xprt *); 63 static void svc_sock_free(struct svc_xprt *); 64 65 static struct svc_xprt *svc_create_socket(struct svc_serv *, int, 66 struct sockaddr *, int, int); 67 #ifdef CONFIG_DEBUG_LOCK_ALLOC 68 static struct lock_class_key svc_key[2]; 69 static struct lock_class_key svc_slock_key[2]; 70 71 static void svc_reclassify_socket(struct socket *sock) 72 { 73 struct sock *sk = sock->sk; 74 BUG_ON(sock_owned_by_user(sk)); 75 switch (sk->sk_family) { 76 case AF_INET: 77 sock_lock_init_class_and_name(sk, "slock-AF_INET-NFSD", 78 &svc_slock_key[0], 79 "sk_xprt.xpt_lock-AF_INET-NFSD", 80 &svc_key[0]); 81 break; 82 83 case AF_INET6: 84 sock_lock_init_class_and_name(sk, "slock-AF_INET6-NFSD", 85 &svc_slock_key[1], 86 "sk_xprt.xpt_lock-AF_INET6-NFSD", 87 &svc_key[1]); 88 break; 89 90 default: 91 BUG(); 92 } 93 } 94 #else 95 static void svc_reclassify_socket(struct socket *sock) 96 { 97 } 98 #endif 99 100 /* 101 * Release an skbuff after use 102 */ 103 static void svc_release_skb(struct svc_rqst *rqstp) 104 { 105 struct sk_buff *skb = rqstp->rq_xprt_ctxt; 106 107 if (skb) { 108 struct svc_sock *svsk = 109 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); 110 rqstp->rq_xprt_ctxt = NULL; 111 112 dprintk("svc: service %p, releasing skb %p\n", rqstp, skb); 113 skb_free_datagram(svsk->sk_sk, skb); 114 } 115 } 116 117 union svc_pktinfo_u { 118 struct in_pktinfo pkti; 119 struct in6_pktinfo pkti6; 120 }; 121 #define SVC_PKTINFO_SPACE \ 122 CMSG_SPACE(sizeof(union svc_pktinfo_u)) 123 124 static void svc_set_cmsg_data(struct svc_rqst *rqstp, struct cmsghdr *cmh) 125 { 126 struct svc_sock *svsk = 127 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); 128 switch (svsk->sk_sk->sk_family) { 129 case AF_INET: { 130 struct in_pktinfo *pki = CMSG_DATA(cmh); 131 132 cmh->cmsg_level = SOL_IP; 133 cmh->cmsg_type = IP_PKTINFO; 134 pki->ipi_ifindex = 0; 135 pki->ipi_spec_dst.s_addr = rqstp->rq_daddr.addr.s_addr; 136 cmh->cmsg_len = CMSG_LEN(sizeof(*pki)); 137 } 138 break; 139 140 case AF_INET6: { 141 struct in6_pktinfo *pki = CMSG_DATA(cmh); 142 143 cmh->cmsg_level = SOL_IPV6; 144 cmh->cmsg_type = IPV6_PKTINFO; 145 pki->ipi6_ifindex = 0; 146 ipv6_addr_copy(&pki->ipi6_addr, 147 &rqstp->rq_daddr.addr6); 148 cmh->cmsg_len = CMSG_LEN(sizeof(*pki)); 149 } 150 break; 151 } 152 return; 153 } 154 155 /* 156 * Generic sendto routine 157 */ 158 static int svc_sendto(struct svc_rqst *rqstp, struct xdr_buf *xdr) 159 { 160 struct svc_sock *svsk = 161 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); 162 struct socket *sock = svsk->sk_sock; 163 int slen; 164 union { 165 struct cmsghdr hdr; 166 long all[SVC_PKTINFO_SPACE / sizeof(long)]; 167 } buffer; 168 struct cmsghdr *cmh = &buffer.hdr; 169 int len = 0; 170 int result; 171 int size; 172 struct page **ppage = xdr->pages; 173 size_t base = xdr->page_base; 174 unsigned int pglen = xdr->page_len; 175 unsigned int flags = MSG_MORE; 176 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]); 177 178 slen = xdr->len; 179 180 if (rqstp->rq_prot == IPPROTO_UDP) { 181 struct msghdr msg = { 182 .msg_name = &rqstp->rq_addr, 183 .msg_namelen = rqstp->rq_addrlen, 184 .msg_control = cmh, 185 .msg_controllen = sizeof(buffer), 186 .msg_flags = MSG_MORE, 187 }; 188 189 svc_set_cmsg_data(rqstp, cmh); 190 191 if (sock_sendmsg(sock, &msg, 0) < 0) 192 goto out; 193 } 194 195 /* send head */ 196 if (slen == xdr->head[0].iov_len) 197 flags = 0; 198 len = kernel_sendpage(sock, rqstp->rq_respages[0], 0, 199 xdr->head[0].iov_len, flags); 200 if (len != xdr->head[0].iov_len) 201 goto out; 202 slen -= xdr->head[0].iov_len; 203 if (slen == 0) 204 goto out; 205 206 /* send page data */ 207 size = PAGE_SIZE - base < pglen ? PAGE_SIZE - base : pglen; 208 while (pglen > 0) { 209 if (slen == size) 210 flags = 0; 211 result = kernel_sendpage(sock, *ppage, base, size, flags); 212 if (result > 0) 213 len += result; 214 if (result != size) 215 goto out; 216 slen -= size; 217 pglen -= size; 218 size = PAGE_SIZE < pglen ? PAGE_SIZE : pglen; 219 base = 0; 220 ppage++; 221 } 222 /* send tail */ 223 if (xdr->tail[0].iov_len) { 224 result = kernel_sendpage(sock, rqstp->rq_respages[0], 225 ((unsigned long)xdr->tail[0].iov_base) 226 & (PAGE_SIZE-1), 227 xdr->tail[0].iov_len, 0); 228 229 if (result > 0) 230 len += result; 231 } 232 out: 233 dprintk("svc: socket %p sendto([%p %Zu... ], %d) = %d (addr %s)\n", 234 svsk, xdr->head[0].iov_base, xdr->head[0].iov_len, 235 xdr->len, len, svc_print_addr(rqstp, buf, sizeof(buf))); 236 237 return len; 238 } 239 240 /* 241 * Report socket names for nfsdfs 242 */ 243 static int one_sock_name(char *buf, struct svc_sock *svsk) 244 { 245 int len; 246 247 switch(svsk->sk_sk->sk_family) { 248 case AF_INET: 249 len = sprintf(buf, "ipv4 %s %pI4 %d\n", 250 svsk->sk_sk->sk_protocol == IPPROTO_UDP ? 251 "udp" : "tcp", 252 &inet_sk(svsk->sk_sk)->rcv_saddr, 253 inet_sk(svsk->sk_sk)->num); 254 break; 255 default: 256 len = sprintf(buf, "*unknown-%d*\n", 257 svsk->sk_sk->sk_family); 258 } 259 return len; 260 } 261 262 int 263 svc_sock_names(char *buf, struct svc_serv *serv, char *toclose) 264 { 265 struct svc_sock *svsk, *closesk = NULL; 266 int len = 0; 267 268 if (!serv) 269 return 0; 270 spin_lock_bh(&serv->sv_lock); 271 list_for_each_entry(svsk, &serv->sv_permsocks, sk_xprt.xpt_list) { 272 int onelen = one_sock_name(buf+len, svsk); 273 if (toclose && strcmp(toclose, buf+len) == 0) 274 closesk = svsk; 275 else 276 len += onelen; 277 } 278 spin_unlock_bh(&serv->sv_lock); 279 if (closesk) 280 /* Should unregister with portmap, but you cannot 281 * unregister just one protocol... 282 */ 283 svc_close_xprt(&closesk->sk_xprt); 284 else if (toclose) 285 return -ENOENT; 286 return len; 287 } 288 EXPORT_SYMBOL_GPL(svc_sock_names); 289 290 /* 291 * Check input queue length 292 */ 293 static int svc_recv_available(struct svc_sock *svsk) 294 { 295 struct socket *sock = svsk->sk_sock; 296 int avail, err; 297 298 err = kernel_sock_ioctl(sock, TIOCINQ, (unsigned long) &avail); 299 300 return (err >= 0)? avail : err; 301 } 302 303 /* 304 * Generic recvfrom routine. 305 */ 306 static int svc_recvfrom(struct svc_rqst *rqstp, struct kvec *iov, int nr, 307 int buflen) 308 { 309 struct svc_sock *svsk = 310 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); 311 struct msghdr msg = { 312 .msg_flags = MSG_DONTWAIT, 313 }; 314 int len; 315 316 rqstp->rq_xprt_hlen = 0; 317 318 len = kernel_recvmsg(svsk->sk_sock, &msg, iov, nr, buflen, 319 msg.msg_flags); 320 321 dprintk("svc: socket %p recvfrom(%p, %Zu) = %d\n", 322 svsk, iov[0].iov_base, iov[0].iov_len, len); 323 return len; 324 } 325 326 /* 327 * Set socket snd and rcv buffer lengths 328 */ 329 static void svc_sock_setbufsize(struct socket *sock, unsigned int snd, 330 unsigned int rcv) 331 { 332 #if 0 333 mm_segment_t oldfs; 334 oldfs = get_fs(); set_fs(KERNEL_DS); 335 sock_setsockopt(sock, SOL_SOCKET, SO_SNDBUF, 336 (char*)&snd, sizeof(snd)); 337 sock_setsockopt(sock, SOL_SOCKET, SO_RCVBUF, 338 (char*)&rcv, sizeof(rcv)); 339 #else 340 /* sock_setsockopt limits use to sysctl_?mem_max, 341 * which isn't acceptable. Until that is made conditional 342 * on not having CAP_SYS_RESOURCE or similar, we go direct... 343 * DaveM said I could! 344 */ 345 lock_sock(sock->sk); 346 sock->sk->sk_sndbuf = snd * 2; 347 sock->sk->sk_rcvbuf = rcv * 2; 348 release_sock(sock->sk); 349 #endif 350 } 351 /* 352 * INET callback when data has been received on the socket. 353 */ 354 static void svc_udp_data_ready(struct sock *sk, int count) 355 { 356 struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data; 357 358 if (svsk) { 359 dprintk("svc: socket %p(inet %p), count=%d, busy=%d\n", 360 svsk, sk, count, 361 test_bit(XPT_BUSY, &svsk->sk_xprt.xpt_flags)); 362 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 363 svc_xprt_enqueue(&svsk->sk_xprt); 364 } 365 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 366 wake_up_interruptible(sk->sk_sleep); 367 } 368 369 /* 370 * INET callback when space is newly available on the socket. 371 */ 372 static void svc_write_space(struct sock *sk) 373 { 374 struct svc_sock *svsk = (struct svc_sock *)(sk->sk_user_data); 375 376 if (svsk) { 377 dprintk("svc: socket %p(inet %p), write_space busy=%d\n", 378 svsk, sk, test_bit(XPT_BUSY, &svsk->sk_xprt.xpt_flags)); 379 svc_xprt_enqueue(&svsk->sk_xprt); 380 } 381 382 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) { 383 dprintk("RPC svc_write_space: someone sleeping on %p\n", 384 svsk); 385 wake_up_interruptible(sk->sk_sleep); 386 } 387 } 388 389 /* 390 * Copy the UDP datagram's destination address to the rqstp structure. 391 * The 'destination' address in this case is the address to which the 392 * peer sent the datagram, i.e. our local address. For multihomed 393 * hosts, this can change from msg to msg. Note that only the IP 394 * address changes, the port number should remain the same. 395 */ 396 static void svc_udp_get_dest_address(struct svc_rqst *rqstp, 397 struct cmsghdr *cmh) 398 { 399 struct svc_sock *svsk = 400 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); 401 switch (svsk->sk_sk->sk_family) { 402 case AF_INET: { 403 struct in_pktinfo *pki = CMSG_DATA(cmh); 404 rqstp->rq_daddr.addr.s_addr = pki->ipi_spec_dst.s_addr; 405 break; 406 } 407 case AF_INET6: { 408 struct in6_pktinfo *pki = CMSG_DATA(cmh); 409 ipv6_addr_copy(&rqstp->rq_daddr.addr6, &pki->ipi6_addr); 410 break; 411 } 412 } 413 } 414 415 /* 416 * Receive a datagram from a UDP socket. 417 */ 418 static int svc_udp_recvfrom(struct svc_rqst *rqstp) 419 { 420 struct svc_sock *svsk = 421 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); 422 struct svc_serv *serv = svsk->sk_xprt.xpt_server; 423 struct sk_buff *skb; 424 union { 425 struct cmsghdr hdr; 426 long all[SVC_PKTINFO_SPACE / sizeof(long)]; 427 } buffer; 428 struct cmsghdr *cmh = &buffer.hdr; 429 int err, len; 430 struct msghdr msg = { 431 .msg_name = svc_addr(rqstp), 432 .msg_control = cmh, 433 .msg_controllen = sizeof(buffer), 434 .msg_flags = MSG_DONTWAIT, 435 }; 436 437 if (test_and_clear_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags)) 438 /* udp sockets need large rcvbuf as all pending 439 * requests are still in that buffer. sndbuf must 440 * also be large enough that there is enough space 441 * for one reply per thread. We count all threads 442 * rather than threads in a particular pool, which 443 * provides an upper bound on the number of threads 444 * which will access the socket. 445 */ 446 svc_sock_setbufsize(svsk->sk_sock, 447 (serv->sv_nrthreads+3) * serv->sv_max_mesg, 448 (serv->sv_nrthreads+3) * serv->sv_max_mesg); 449 450 clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 451 skb = NULL; 452 err = kernel_recvmsg(svsk->sk_sock, &msg, NULL, 453 0, 0, MSG_PEEK | MSG_DONTWAIT); 454 if (err >= 0) 455 skb = skb_recv_datagram(svsk->sk_sk, 0, 1, &err); 456 457 if (skb == NULL) { 458 if (err != -EAGAIN) { 459 /* possibly an icmp error */ 460 dprintk("svc: recvfrom returned error %d\n", -err); 461 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 462 } 463 svc_xprt_received(&svsk->sk_xprt); 464 return -EAGAIN; 465 } 466 len = svc_addr_len(svc_addr(rqstp)); 467 if (len < 0) 468 return len; 469 rqstp->rq_addrlen = len; 470 if (skb->tstamp.tv64 == 0) { 471 skb->tstamp = ktime_get_real(); 472 /* Don't enable netstamp, sunrpc doesn't 473 need that much accuracy */ 474 } 475 svsk->sk_sk->sk_stamp = skb->tstamp; 476 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); /* there may be more data... */ 477 478 /* 479 * Maybe more packets - kick another thread ASAP. 480 */ 481 svc_xprt_received(&svsk->sk_xprt); 482 483 len = skb->len - sizeof(struct udphdr); 484 rqstp->rq_arg.len = len; 485 486 rqstp->rq_prot = IPPROTO_UDP; 487 488 if (cmh->cmsg_level != IPPROTO_IP || 489 cmh->cmsg_type != IP_PKTINFO) { 490 if (net_ratelimit()) 491 printk("rpcsvc: received unknown control message:" 492 "%d/%d\n", 493 cmh->cmsg_level, cmh->cmsg_type); 494 skb_free_datagram(svsk->sk_sk, skb); 495 return 0; 496 } 497 svc_udp_get_dest_address(rqstp, cmh); 498 499 if (skb_is_nonlinear(skb)) { 500 /* we have to copy */ 501 local_bh_disable(); 502 if (csum_partial_copy_to_xdr(&rqstp->rq_arg, skb)) { 503 local_bh_enable(); 504 /* checksum error */ 505 skb_free_datagram(svsk->sk_sk, skb); 506 return 0; 507 } 508 local_bh_enable(); 509 skb_free_datagram(svsk->sk_sk, skb); 510 } else { 511 /* we can use it in-place */ 512 rqstp->rq_arg.head[0].iov_base = skb->data + 513 sizeof(struct udphdr); 514 rqstp->rq_arg.head[0].iov_len = len; 515 if (skb_checksum_complete(skb)) { 516 skb_free_datagram(svsk->sk_sk, skb); 517 return 0; 518 } 519 rqstp->rq_xprt_ctxt = skb; 520 } 521 522 rqstp->rq_arg.page_base = 0; 523 if (len <= rqstp->rq_arg.head[0].iov_len) { 524 rqstp->rq_arg.head[0].iov_len = len; 525 rqstp->rq_arg.page_len = 0; 526 rqstp->rq_respages = rqstp->rq_pages+1; 527 } else { 528 rqstp->rq_arg.page_len = len - rqstp->rq_arg.head[0].iov_len; 529 rqstp->rq_respages = rqstp->rq_pages + 1 + 530 DIV_ROUND_UP(rqstp->rq_arg.page_len, PAGE_SIZE); 531 } 532 533 if (serv->sv_stats) 534 serv->sv_stats->netudpcnt++; 535 536 return len; 537 } 538 539 static int 540 svc_udp_sendto(struct svc_rqst *rqstp) 541 { 542 int error; 543 544 error = svc_sendto(rqstp, &rqstp->rq_res); 545 if (error == -ECONNREFUSED) 546 /* ICMP error on earlier request. */ 547 error = svc_sendto(rqstp, &rqstp->rq_res); 548 549 return error; 550 } 551 552 static void svc_udp_prep_reply_hdr(struct svc_rqst *rqstp) 553 { 554 } 555 556 static int svc_udp_has_wspace(struct svc_xprt *xprt) 557 { 558 struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt); 559 struct svc_serv *serv = xprt->xpt_server; 560 unsigned long required; 561 562 /* 563 * Set the SOCK_NOSPACE flag before checking the available 564 * sock space. 565 */ 566 set_bit(SOCK_NOSPACE, &svsk->sk_sock->flags); 567 required = atomic_read(&svsk->sk_xprt.xpt_reserved) + serv->sv_max_mesg; 568 if (required*2 > sock_wspace(svsk->sk_sk)) 569 return 0; 570 clear_bit(SOCK_NOSPACE, &svsk->sk_sock->flags); 571 return 1; 572 } 573 574 static struct svc_xprt *svc_udp_accept(struct svc_xprt *xprt) 575 { 576 BUG(); 577 return NULL; 578 } 579 580 static struct svc_xprt *svc_udp_create(struct svc_serv *serv, 581 struct sockaddr *sa, int salen, 582 int flags) 583 { 584 return svc_create_socket(serv, IPPROTO_UDP, sa, salen, flags); 585 } 586 587 static struct svc_xprt_ops svc_udp_ops = { 588 .xpo_create = svc_udp_create, 589 .xpo_recvfrom = svc_udp_recvfrom, 590 .xpo_sendto = svc_udp_sendto, 591 .xpo_release_rqst = svc_release_skb, 592 .xpo_detach = svc_sock_detach, 593 .xpo_free = svc_sock_free, 594 .xpo_prep_reply_hdr = svc_udp_prep_reply_hdr, 595 .xpo_has_wspace = svc_udp_has_wspace, 596 .xpo_accept = svc_udp_accept, 597 }; 598 599 static struct svc_xprt_class svc_udp_class = { 600 .xcl_name = "udp", 601 .xcl_owner = THIS_MODULE, 602 .xcl_ops = &svc_udp_ops, 603 .xcl_max_payload = RPCSVC_MAXPAYLOAD_UDP, 604 }; 605 606 static void svc_udp_init(struct svc_sock *svsk, struct svc_serv *serv) 607 { 608 int one = 1; 609 mm_segment_t oldfs; 610 611 svc_xprt_init(&svc_udp_class, &svsk->sk_xprt, serv); 612 clear_bit(XPT_CACHE_AUTH, &svsk->sk_xprt.xpt_flags); 613 svsk->sk_sk->sk_data_ready = svc_udp_data_ready; 614 svsk->sk_sk->sk_write_space = svc_write_space; 615 616 /* initialise setting must have enough space to 617 * receive and respond to one request. 618 * svc_udp_recvfrom will re-adjust if necessary 619 */ 620 svc_sock_setbufsize(svsk->sk_sock, 621 3 * svsk->sk_xprt.xpt_server->sv_max_mesg, 622 3 * svsk->sk_xprt.xpt_server->sv_max_mesg); 623 624 /* data might have come in before data_ready set up */ 625 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 626 set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags); 627 628 oldfs = get_fs(); 629 set_fs(KERNEL_DS); 630 /* make sure we get destination address info */ 631 svsk->sk_sock->ops->setsockopt(svsk->sk_sock, IPPROTO_IP, IP_PKTINFO, 632 (char __user *)&one, sizeof(one)); 633 set_fs(oldfs); 634 } 635 636 /* 637 * A data_ready event on a listening socket means there's a connection 638 * pending. Do not use state_change as a substitute for it. 639 */ 640 static void svc_tcp_listen_data_ready(struct sock *sk, int count_unused) 641 { 642 struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data; 643 644 dprintk("svc: socket %p TCP (listen) state change %d\n", 645 sk, sk->sk_state); 646 647 /* 648 * This callback may called twice when a new connection 649 * is established as a child socket inherits everything 650 * from a parent LISTEN socket. 651 * 1) data_ready method of the parent socket will be called 652 * when one of child sockets become ESTABLISHED. 653 * 2) data_ready method of the child socket may be called 654 * when it receives data before the socket is accepted. 655 * In case of 2, we should ignore it silently. 656 */ 657 if (sk->sk_state == TCP_LISTEN) { 658 if (svsk) { 659 set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags); 660 svc_xprt_enqueue(&svsk->sk_xprt); 661 } else 662 printk("svc: socket %p: no user data\n", sk); 663 } 664 665 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 666 wake_up_interruptible_all(sk->sk_sleep); 667 } 668 669 /* 670 * A state change on a connected socket means it's dying or dead. 671 */ 672 static void svc_tcp_state_change(struct sock *sk) 673 { 674 struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data; 675 676 dprintk("svc: socket %p TCP (connected) state change %d (svsk %p)\n", 677 sk, sk->sk_state, sk->sk_user_data); 678 679 if (!svsk) 680 printk("svc: socket %p: no user data\n", sk); 681 else { 682 set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags); 683 svc_xprt_enqueue(&svsk->sk_xprt); 684 } 685 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 686 wake_up_interruptible_all(sk->sk_sleep); 687 } 688 689 static void svc_tcp_data_ready(struct sock *sk, int count) 690 { 691 struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data; 692 693 dprintk("svc: socket %p TCP data ready (svsk %p)\n", 694 sk, sk->sk_user_data); 695 if (svsk) { 696 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 697 svc_xprt_enqueue(&svsk->sk_xprt); 698 } 699 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 700 wake_up_interruptible(sk->sk_sleep); 701 } 702 703 /* 704 * Accept a TCP connection 705 */ 706 static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt) 707 { 708 struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt); 709 struct sockaddr_storage addr; 710 struct sockaddr *sin = (struct sockaddr *) &addr; 711 struct svc_serv *serv = svsk->sk_xprt.xpt_server; 712 struct socket *sock = svsk->sk_sock; 713 struct socket *newsock; 714 struct svc_sock *newsvsk; 715 int err, slen; 716 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]); 717 718 dprintk("svc: tcp_accept %p sock %p\n", svsk, sock); 719 if (!sock) 720 return NULL; 721 722 clear_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags); 723 err = kernel_accept(sock, &newsock, O_NONBLOCK); 724 if (err < 0) { 725 if (err == -ENOMEM) 726 printk(KERN_WARNING "%s: no more sockets!\n", 727 serv->sv_name); 728 else if (err != -EAGAIN && net_ratelimit()) 729 printk(KERN_WARNING "%s: accept failed (err %d)!\n", 730 serv->sv_name, -err); 731 return NULL; 732 } 733 set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags); 734 735 err = kernel_getpeername(newsock, sin, &slen); 736 if (err < 0) { 737 if (net_ratelimit()) 738 printk(KERN_WARNING "%s: peername failed (err %d)!\n", 739 serv->sv_name, -err); 740 goto failed; /* aborted connection or whatever */ 741 } 742 743 /* Ideally, we would want to reject connections from unauthorized 744 * hosts here, but when we get encryption, the IP of the host won't 745 * tell us anything. For now just warn about unpriv connections. 746 */ 747 if (!svc_port_is_privileged(sin)) { 748 dprintk(KERN_WARNING 749 "%s: connect from unprivileged port: %s\n", 750 serv->sv_name, 751 __svc_print_addr(sin, buf, sizeof(buf))); 752 } 753 dprintk("%s: connect from %s\n", serv->sv_name, 754 __svc_print_addr(sin, buf, sizeof(buf))); 755 756 /* make sure that a write doesn't block forever when 757 * low on memory 758 */ 759 newsock->sk->sk_sndtimeo = HZ*30; 760 761 if (!(newsvsk = svc_setup_socket(serv, newsock, &err, 762 (SVC_SOCK_ANONYMOUS | SVC_SOCK_TEMPORARY)))) 763 goto failed; 764 svc_xprt_set_remote(&newsvsk->sk_xprt, sin, slen); 765 err = kernel_getsockname(newsock, sin, &slen); 766 if (unlikely(err < 0)) { 767 dprintk("svc_tcp_accept: kernel_getsockname error %d\n", -err); 768 slen = offsetof(struct sockaddr, sa_data); 769 } 770 svc_xprt_set_local(&newsvsk->sk_xprt, sin, slen); 771 772 if (serv->sv_stats) 773 serv->sv_stats->nettcpconn++; 774 775 return &newsvsk->sk_xprt; 776 777 failed: 778 sock_release(newsock); 779 return NULL; 780 } 781 782 /* 783 * Receive data from a TCP socket. 784 */ 785 static int svc_tcp_recvfrom(struct svc_rqst *rqstp) 786 { 787 struct svc_sock *svsk = 788 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); 789 struct svc_serv *serv = svsk->sk_xprt.xpt_server; 790 int len; 791 struct kvec *vec; 792 int pnum, vlen; 793 794 dprintk("svc: tcp_recv %p data %d conn %d close %d\n", 795 svsk, test_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags), 796 test_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags), 797 test_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags)); 798 799 clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 800 801 /* Receive data. If we haven't got the record length yet, get 802 * the next four bytes. Otherwise try to gobble up as much as 803 * possible up to the complete record length. 804 */ 805 if (svsk->sk_tcplen < sizeof(rpc_fraghdr)) { 806 int want = sizeof(rpc_fraghdr) - svsk->sk_tcplen; 807 struct kvec iov; 808 809 iov.iov_base = ((char *) &svsk->sk_reclen) + svsk->sk_tcplen; 810 iov.iov_len = want; 811 if ((len = svc_recvfrom(rqstp, &iov, 1, want)) < 0) 812 goto error; 813 svsk->sk_tcplen += len; 814 815 if (len < want) { 816 dprintk("svc: short recvfrom while reading record " 817 "length (%d of %d)\n", len, want); 818 svc_xprt_received(&svsk->sk_xprt); 819 return -EAGAIN; /* record header not complete */ 820 } 821 822 svsk->sk_reclen = ntohl(svsk->sk_reclen); 823 if (!(svsk->sk_reclen & RPC_LAST_STREAM_FRAGMENT)) { 824 /* FIXME: technically, a record can be fragmented, 825 * and non-terminal fragments will not have the top 826 * bit set in the fragment length header. 827 * But apparently no known nfs clients send fragmented 828 * records. */ 829 if (net_ratelimit()) 830 printk(KERN_NOTICE "RPC: multiple fragments " 831 "per record not supported\n"); 832 goto err_delete; 833 } 834 svsk->sk_reclen &= RPC_FRAGMENT_SIZE_MASK; 835 dprintk("svc: TCP record, %d bytes\n", svsk->sk_reclen); 836 if (svsk->sk_reclen > serv->sv_max_mesg) { 837 if (net_ratelimit()) 838 printk(KERN_NOTICE "RPC: " 839 "fragment too large: 0x%08lx\n", 840 (unsigned long)svsk->sk_reclen); 841 goto err_delete; 842 } 843 } 844 845 /* Check whether enough data is available */ 846 len = svc_recv_available(svsk); 847 if (len < 0) 848 goto error; 849 850 if (len < svsk->sk_reclen) { 851 dprintk("svc: incomplete TCP record (%d of %d)\n", 852 len, svsk->sk_reclen); 853 svc_xprt_received(&svsk->sk_xprt); 854 return -EAGAIN; /* record not complete */ 855 } 856 len = svsk->sk_reclen; 857 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 858 859 vec = rqstp->rq_vec; 860 vec[0] = rqstp->rq_arg.head[0]; 861 vlen = PAGE_SIZE; 862 pnum = 1; 863 while (vlen < len) { 864 vec[pnum].iov_base = page_address(rqstp->rq_pages[pnum]); 865 vec[pnum].iov_len = PAGE_SIZE; 866 pnum++; 867 vlen += PAGE_SIZE; 868 } 869 rqstp->rq_respages = &rqstp->rq_pages[pnum]; 870 871 /* Now receive data */ 872 len = svc_recvfrom(rqstp, vec, pnum, len); 873 if (len < 0) 874 goto error; 875 876 dprintk("svc: TCP complete record (%d bytes)\n", len); 877 rqstp->rq_arg.len = len; 878 rqstp->rq_arg.page_base = 0; 879 if (len <= rqstp->rq_arg.head[0].iov_len) { 880 rqstp->rq_arg.head[0].iov_len = len; 881 rqstp->rq_arg.page_len = 0; 882 } else { 883 rqstp->rq_arg.page_len = len - rqstp->rq_arg.head[0].iov_len; 884 } 885 886 rqstp->rq_xprt_ctxt = NULL; 887 rqstp->rq_prot = IPPROTO_TCP; 888 889 /* Reset TCP read info */ 890 svsk->sk_reclen = 0; 891 svsk->sk_tcplen = 0; 892 893 svc_xprt_copy_addrs(rqstp, &svsk->sk_xprt); 894 svc_xprt_received(&svsk->sk_xprt); 895 if (serv->sv_stats) 896 serv->sv_stats->nettcpcnt++; 897 898 return len; 899 900 err_delete: 901 set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags); 902 return -EAGAIN; 903 904 error: 905 if (len == -EAGAIN) { 906 dprintk("RPC: TCP recvfrom got EAGAIN\n"); 907 svc_xprt_received(&svsk->sk_xprt); 908 } else { 909 printk(KERN_NOTICE "%s: recvfrom returned errno %d\n", 910 svsk->sk_xprt.xpt_server->sv_name, -len); 911 goto err_delete; 912 } 913 914 return len; 915 } 916 917 /* 918 * Send out data on TCP socket. 919 */ 920 static int svc_tcp_sendto(struct svc_rqst *rqstp) 921 { 922 struct xdr_buf *xbufp = &rqstp->rq_res; 923 int sent; 924 __be32 reclen; 925 926 /* Set up the first element of the reply kvec. 927 * Any other kvecs that may be in use have been taken 928 * care of by the server implementation itself. 929 */ 930 reclen = htonl(0x80000000|((xbufp->len ) - 4)); 931 memcpy(xbufp->head[0].iov_base, &reclen, 4); 932 933 if (test_bit(XPT_DEAD, &rqstp->rq_xprt->xpt_flags)) 934 return -ENOTCONN; 935 936 sent = svc_sendto(rqstp, &rqstp->rq_res); 937 if (sent != xbufp->len) { 938 printk(KERN_NOTICE 939 "rpc-srv/tcp: %s: %s %d when sending %d bytes " 940 "- shutting down socket\n", 941 rqstp->rq_xprt->xpt_server->sv_name, 942 (sent<0)?"got error":"sent only", 943 sent, xbufp->len); 944 set_bit(XPT_CLOSE, &rqstp->rq_xprt->xpt_flags); 945 svc_xprt_enqueue(rqstp->rq_xprt); 946 sent = -EAGAIN; 947 } 948 return sent; 949 } 950 951 /* 952 * Setup response header. TCP has a 4B record length field. 953 */ 954 static void svc_tcp_prep_reply_hdr(struct svc_rqst *rqstp) 955 { 956 struct kvec *resv = &rqstp->rq_res.head[0]; 957 958 /* tcp needs a space for the record length... */ 959 svc_putnl(resv, 0); 960 } 961 962 static int svc_tcp_has_wspace(struct svc_xprt *xprt) 963 { 964 struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt); 965 struct svc_serv *serv = svsk->sk_xprt.xpt_server; 966 int required; 967 int wspace; 968 969 /* 970 * Set the SOCK_NOSPACE flag before checking the available 971 * sock space. 972 */ 973 set_bit(SOCK_NOSPACE, &svsk->sk_sock->flags); 974 required = atomic_read(&svsk->sk_xprt.xpt_reserved) + serv->sv_max_mesg; 975 wspace = sk_stream_wspace(svsk->sk_sk); 976 977 if (wspace < sk_stream_min_wspace(svsk->sk_sk)) 978 return 0; 979 if (required * 2 > wspace) 980 return 0; 981 982 clear_bit(SOCK_NOSPACE, &svsk->sk_sock->flags); 983 return 1; 984 } 985 986 static struct svc_xprt *svc_tcp_create(struct svc_serv *serv, 987 struct sockaddr *sa, int salen, 988 int flags) 989 { 990 return svc_create_socket(serv, IPPROTO_TCP, sa, salen, flags); 991 } 992 993 static struct svc_xprt_ops svc_tcp_ops = { 994 .xpo_create = svc_tcp_create, 995 .xpo_recvfrom = svc_tcp_recvfrom, 996 .xpo_sendto = svc_tcp_sendto, 997 .xpo_release_rqst = svc_release_skb, 998 .xpo_detach = svc_tcp_sock_detach, 999 .xpo_free = svc_sock_free, 1000 .xpo_prep_reply_hdr = svc_tcp_prep_reply_hdr, 1001 .xpo_has_wspace = svc_tcp_has_wspace, 1002 .xpo_accept = svc_tcp_accept, 1003 }; 1004 1005 static struct svc_xprt_class svc_tcp_class = { 1006 .xcl_name = "tcp", 1007 .xcl_owner = THIS_MODULE, 1008 .xcl_ops = &svc_tcp_ops, 1009 .xcl_max_payload = RPCSVC_MAXPAYLOAD_TCP, 1010 }; 1011 1012 void svc_init_xprt_sock(void) 1013 { 1014 svc_reg_xprt_class(&svc_tcp_class); 1015 svc_reg_xprt_class(&svc_udp_class); 1016 } 1017 1018 void svc_cleanup_xprt_sock(void) 1019 { 1020 svc_unreg_xprt_class(&svc_tcp_class); 1021 svc_unreg_xprt_class(&svc_udp_class); 1022 } 1023 1024 static void svc_tcp_init(struct svc_sock *svsk, struct svc_serv *serv) 1025 { 1026 struct sock *sk = svsk->sk_sk; 1027 1028 svc_xprt_init(&svc_tcp_class, &svsk->sk_xprt, serv); 1029 set_bit(XPT_CACHE_AUTH, &svsk->sk_xprt.xpt_flags); 1030 if (sk->sk_state == TCP_LISTEN) { 1031 dprintk("setting up TCP socket for listening\n"); 1032 set_bit(XPT_LISTENER, &svsk->sk_xprt.xpt_flags); 1033 sk->sk_data_ready = svc_tcp_listen_data_ready; 1034 set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags); 1035 } else { 1036 dprintk("setting up TCP socket for reading\n"); 1037 sk->sk_state_change = svc_tcp_state_change; 1038 sk->sk_data_ready = svc_tcp_data_ready; 1039 sk->sk_write_space = svc_write_space; 1040 1041 svsk->sk_reclen = 0; 1042 svsk->sk_tcplen = 0; 1043 1044 tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF; 1045 1046 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 1047 if (sk->sk_state != TCP_ESTABLISHED) 1048 set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags); 1049 } 1050 } 1051 1052 void svc_sock_update_bufs(struct svc_serv *serv) 1053 { 1054 /* 1055 * The number of server threads has changed. Update 1056 * rcvbuf and sndbuf accordingly on all sockets 1057 */ 1058 struct list_head *le; 1059 1060 spin_lock_bh(&serv->sv_lock); 1061 list_for_each(le, &serv->sv_permsocks) { 1062 struct svc_sock *svsk = 1063 list_entry(le, struct svc_sock, sk_xprt.xpt_list); 1064 set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags); 1065 } 1066 list_for_each(le, &serv->sv_tempsocks) { 1067 struct svc_sock *svsk = 1068 list_entry(le, struct svc_sock, sk_xprt.xpt_list); 1069 set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags); 1070 } 1071 spin_unlock_bh(&serv->sv_lock); 1072 } 1073 EXPORT_SYMBOL_GPL(svc_sock_update_bufs); 1074 1075 /* 1076 * Initialize socket for RPC use and create svc_sock struct 1077 * XXX: May want to setsockopt SO_SNDBUF and SO_RCVBUF. 1078 */ 1079 static struct svc_sock *svc_setup_socket(struct svc_serv *serv, 1080 struct socket *sock, 1081 int *errp, int flags) 1082 { 1083 struct svc_sock *svsk; 1084 struct sock *inet; 1085 int pmap_register = !(flags & SVC_SOCK_ANONYMOUS); 1086 1087 dprintk("svc: svc_setup_socket %p\n", sock); 1088 if (!(svsk = kzalloc(sizeof(*svsk), GFP_KERNEL))) { 1089 *errp = -ENOMEM; 1090 return NULL; 1091 } 1092 1093 inet = sock->sk; 1094 1095 /* Register socket with portmapper */ 1096 if (*errp >= 0 && pmap_register) 1097 *errp = svc_register(serv, inet->sk_family, inet->sk_protocol, 1098 ntohs(inet_sk(inet)->sport)); 1099 1100 if (*errp < 0) { 1101 kfree(svsk); 1102 return NULL; 1103 } 1104 1105 inet->sk_user_data = svsk; 1106 svsk->sk_sock = sock; 1107 svsk->sk_sk = inet; 1108 svsk->sk_ostate = inet->sk_state_change; 1109 svsk->sk_odata = inet->sk_data_ready; 1110 svsk->sk_owspace = inet->sk_write_space; 1111 1112 /* Initialize the socket */ 1113 if (sock->type == SOCK_DGRAM) 1114 svc_udp_init(svsk, serv); 1115 else { 1116 /* initialise setting must have enough space to 1117 * receive and respond to one request. 1118 */ 1119 svc_sock_setbufsize(svsk->sk_sock, 4 * serv->sv_max_mesg, 1120 4 * serv->sv_max_mesg); 1121 svc_tcp_init(svsk, serv); 1122 } 1123 1124 dprintk("svc: svc_setup_socket created %p (inet %p)\n", 1125 svsk, svsk->sk_sk); 1126 1127 return svsk; 1128 } 1129 1130 int svc_addsock(struct svc_serv *serv, 1131 int fd, 1132 char *name_return) 1133 { 1134 int err = 0; 1135 struct socket *so = sockfd_lookup(fd, &err); 1136 struct svc_sock *svsk = NULL; 1137 1138 if (!so) 1139 return err; 1140 if (so->sk->sk_family != AF_INET) 1141 err = -EAFNOSUPPORT; 1142 else if (so->sk->sk_protocol != IPPROTO_TCP && 1143 so->sk->sk_protocol != IPPROTO_UDP) 1144 err = -EPROTONOSUPPORT; 1145 else if (so->state > SS_UNCONNECTED) 1146 err = -EISCONN; 1147 else { 1148 if (!try_module_get(THIS_MODULE)) 1149 err = -ENOENT; 1150 else 1151 svsk = svc_setup_socket(serv, so, &err, 1152 SVC_SOCK_DEFAULTS); 1153 if (svsk) { 1154 struct sockaddr_storage addr; 1155 struct sockaddr *sin = (struct sockaddr *)&addr; 1156 int salen; 1157 if (kernel_getsockname(svsk->sk_sock, sin, &salen) == 0) 1158 svc_xprt_set_local(&svsk->sk_xprt, sin, salen); 1159 clear_bit(XPT_TEMP, &svsk->sk_xprt.xpt_flags); 1160 spin_lock_bh(&serv->sv_lock); 1161 list_add(&svsk->sk_xprt.xpt_list, &serv->sv_permsocks); 1162 spin_unlock_bh(&serv->sv_lock); 1163 svc_xprt_received(&svsk->sk_xprt); 1164 err = 0; 1165 } else 1166 module_put(THIS_MODULE); 1167 } 1168 if (err) { 1169 sockfd_put(so); 1170 return err; 1171 } 1172 return one_sock_name(name_return, svsk); 1173 } 1174 EXPORT_SYMBOL_GPL(svc_addsock); 1175 1176 /* 1177 * Create socket for RPC service. 1178 */ 1179 static struct svc_xprt *svc_create_socket(struct svc_serv *serv, 1180 int protocol, 1181 struct sockaddr *sin, int len, 1182 int flags) 1183 { 1184 struct svc_sock *svsk; 1185 struct socket *sock; 1186 int error; 1187 int type; 1188 struct sockaddr_storage addr; 1189 struct sockaddr *newsin = (struct sockaddr *)&addr; 1190 int newlen; 1191 int family; 1192 int val; 1193 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]); 1194 1195 dprintk("svc: svc_create_socket(%s, %d, %s)\n", 1196 serv->sv_program->pg_name, protocol, 1197 __svc_print_addr(sin, buf, sizeof(buf))); 1198 1199 if (protocol != IPPROTO_UDP && protocol != IPPROTO_TCP) { 1200 printk(KERN_WARNING "svc: only UDP and TCP " 1201 "sockets supported\n"); 1202 return ERR_PTR(-EINVAL); 1203 } 1204 1205 type = (protocol == IPPROTO_UDP)? SOCK_DGRAM : SOCK_STREAM; 1206 switch (sin->sa_family) { 1207 case AF_INET6: 1208 family = PF_INET6; 1209 break; 1210 case AF_INET: 1211 family = PF_INET; 1212 break; 1213 default: 1214 return ERR_PTR(-EINVAL); 1215 } 1216 1217 error = sock_create_kern(family, type, protocol, &sock); 1218 if (error < 0) 1219 return ERR_PTR(error); 1220 1221 svc_reclassify_socket(sock); 1222 1223 /* 1224 * If this is an PF_INET6 listener, we want to avoid 1225 * getting requests from IPv4 remotes. Those should 1226 * be shunted to a PF_INET listener via rpcbind. 1227 */ 1228 val = 1; 1229 if (family == PF_INET6) 1230 kernel_setsockopt(sock, SOL_IPV6, IPV6_V6ONLY, 1231 (char *)&val, sizeof(val)); 1232 1233 if (type == SOCK_STREAM) 1234 sock->sk->sk_reuse = 1; /* allow address reuse */ 1235 error = kernel_bind(sock, sin, len); 1236 if (error < 0) 1237 goto bummer; 1238 1239 newlen = len; 1240 error = kernel_getsockname(sock, newsin, &newlen); 1241 if (error < 0) 1242 goto bummer; 1243 1244 if (protocol == IPPROTO_TCP) { 1245 if ((error = kernel_listen(sock, 64)) < 0) 1246 goto bummer; 1247 } 1248 1249 if ((svsk = svc_setup_socket(serv, sock, &error, flags)) != NULL) { 1250 svc_xprt_set_local(&svsk->sk_xprt, newsin, newlen); 1251 return (struct svc_xprt *)svsk; 1252 } 1253 1254 bummer: 1255 dprintk("svc: svc_create_socket error = %d\n", -error); 1256 sock_release(sock); 1257 return ERR_PTR(error); 1258 } 1259 1260 /* 1261 * Detach the svc_sock from the socket so that no 1262 * more callbacks occur. 1263 */ 1264 static void svc_sock_detach(struct svc_xprt *xprt) 1265 { 1266 struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt); 1267 struct sock *sk = svsk->sk_sk; 1268 1269 dprintk("svc: svc_sock_detach(%p)\n", svsk); 1270 1271 /* put back the old socket callbacks */ 1272 sk->sk_state_change = svsk->sk_ostate; 1273 sk->sk_data_ready = svsk->sk_odata; 1274 sk->sk_write_space = svsk->sk_owspace; 1275 1276 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1277 wake_up_interruptible(sk->sk_sleep); 1278 } 1279 1280 /* 1281 * Disconnect the socket, and reset the callbacks 1282 */ 1283 static void svc_tcp_sock_detach(struct svc_xprt *xprt) 1284 { 1285 struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt); 1286 1287 dprintk("svc: svc_tcp_sock_detach(%p)\n", svsk); 1288 1289 svc_sock_detach(xprt); 1290 1291 if (!test_bit(XPT_LISTENER, &xprt->xpt_flags)) 1292 kernel_sock_shutdown(svsk->sk_sock, SHUT_RDWR); 1293 } 1294 1295 /* 1296 * Free the svc_sock's socket resources and the svc_sock itself. 1297 */ 1298 static void svc_sock_free(struct svc_xprt *xprt) 1299 { 1300 struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt); 1301 dprintk("svc: svc_sock_free(%p)\n", svsk); 1302 1303 if (svsk->sk_sock->file) 1304 sockfd_put(svsk->sk_sock); 1305 else 1306 sock_release(svsk->sk_sock); 1307 kfree(svsk); 1308 } 1309