sock.c revision 6d6ee43e0b8b8d4847627fd43739b98ec2b9404f
1/* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * Generic socket support routines. Memory allocators, socket lock/release 7 * handler for protocols to use and generic option handler. 8 * 9 * 10 * Version: $Id: sock.c,v 1.117 2002/02/01 22:01:03 davem Exp $ 11 * 12 * Authors: Ross Biro 13 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 14 * Florian La Roche, <flla@stud.uni-sb.de> 15 * Alan Cox, <A.Cox@swansea.ac.uk> 16 * 17 * Fixes: 18 * Alan Cox : Numerous verify_area() problems 19 * Alan Cox : Connecting on a connecting socket 20 * now returns an error for tcp. 21 * Alan Cox : sock->protocol is set correctly. 22 * and is not sometimes left as 0. 23 * Alan Cox : connect handles icmp errors on a 24 * connect properly. Unfortunately there 25 * is a restart syscall nasty there. I 26 * can't match BSD without hacking the C 27 * library. Ideas urgently sought! 28 * Alan Cox : Disallow bind() to addresses that are 29 * not ours - especially broadcast ones!! 30 * Alan Cox : Socket 1024 _IS_ ok for users. (fencepost) 31 * Alan Cox : sock_wfree/sock_rfree don't destroy sockets, 32 * instead they leave that for the DESTROY timer. 33 * Alan Cox : Clean up error flag in accept 34 * Alan Cox : TCP ack handling is buggy, the DESTROY timer 35 * was buggy. Put a remove_sock() in the handler 36 * for memory when we hit 0. Also altered the timer 37 * code. The ACK stuff can wait and needs major 38 * TCP layer surgery. 39 * Alan Cox : Fixed TCP ack bug, removed remove sock 40 * and fixed timer/inet_bh race. 41 * Alan Cox : Added zapped flag for TCP 42 * Alan Cox : Move kfree_skb into skbuff.c and tidied up surplus code 43 * Alan Cox : for new sk_buff allocations wmalloc/rmalloc now call alloc_skb 44 * Alan Cox : kfree_s calls now are kfree_skbmem so we can track skb resources 45 * Alan Cox : Supports socket option broadcast now as does udp. Packet and raw need fixing. 46 * Alan Cox : Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so... 47 * Rick Sladkey : Relaxed UDP rules for matching packets. 48 * C.E.Hawkins : IFF_PROMISC/SIOCGHWADDR support 49 * Pauline Middelink : identd support 50 * Alan Cox : Fixed connect() taking signals I think. 51 * Alan Cox : SO_LINGER supported 52 * Alan Cox : Error reporting fixes 53 * Anonymous : inet_create tidied up (sk->reuse setting) 54 * Alan Cox : inet sockets don't set sk->type! 55 * Alan Cox : Split socket option code 56 * Alan Cox : Callbacks 57 * Alan Cox : Nagle flag for Charles & Johannes stuff 58 * Alex : Removed restriction on inet fioctl 59 * Alan Cox : Splitting INET from NET core 60 * Alan Cox : Fixed bogus SO_TYPE handling in getsockopt() 61 * Adam Caldwell : Missing return in SO_DONTROUTE/SO_DEBUG code 62 * Alan Cox : Split IP from generic code 63 * Alan Cox : New kfree_skbmem() 64 * Alan Cox : Make SO_DEBUG superuser only. 65 * Alan Cox : Allow anyone to clear SO_DEBUG 66 * (compatibility fix) 67 * Alan Cox : Added optimistic memory grabbing for AF_UNIX throughput. 68 * Alan Cox : Allocator for a socket is settable. 69 * Alan Cox : SO_ERROR includes soft errors. 70 * Alan Cox : Allow NULL arguments on some SO_ opts 71 * Alan Cox : Generic socket allocation to make hooks 72 * easier (suggested by Craig Metz). 73 * Michael Pall : SO_ERROR returns positive errno again 74 * Steve Whitehouse: Added default destructor to free 75 * protocol private data. 76 * Steve Whitehouse: Added various other default routines 77 * common to several socket families. 78 * Chris Evans : Call suser() check last on F_SETOWN 79 * Jay Schulist : Added SO_ATTACH_FILTER and SO_DETACH_FILTER. 80 * Andi Kleen : Add sock_kmalloc()/sock_kfree_s() 81 * Andi Kleen : Fix write_space callback 82 * Chris Evans : Security fixes - signedness again 83 * Arnaldo C. Melo : cleanups, use skb_queue_purge 84 * 85 * To Fix: 86 * 87 * 88 * This program is free software; you can redistribute it and/or 89 * modify it under the terms of the GNU General Public License 90 * as published by the Free Software Foundation; either version 91 * 2 of the License, or (at your option) any later version. 92 */ 93 94#include <linux/config.h> 95#include <linux/errno.h> 96#include <linux/types.h> 97#include <linux/socket.h> 98#include <linux/in.h> 99#include <linux/kernel.h> 100#include <linux/module.h> 101#include <linux/proc_fs.h> 102#include <linux/seq_file.h> 103#include <linux/sched.h> 104#include <linux/timer.h> 105#include <linux/string.h> 106#include <linux/sockios.h> 107#include <linux/net.h> 108#include <linux/mm.h> 109#include <linux/slab.h> 110#include <linux/interrupt.h> 111#include <linux/poll.h> 112#include <linux/tcp.h> 113#include <linux/init.h> 114 115#include <asm/uaccess.h> 116#include <asm/system.h> 117 118#include <linux/netdevice.h> 119#include <net/protocol.h> 120#include <linux/skbuff.h> 121#include <net/request_sock.h> 122#include <net/sock.h> 123#include <net/xfrm.h> 124#include <linux/ipsec.h> 125 126#include <linux/filter.h> 127 128#ifdef CONFIG_INET 129#include <net/tcp.h> 130#endif 131 132/* Take into consideration the size of the struct sk_buff overhead in the 133 * determination of these values, since that is non-constant across 134 * platforms. This makes socket queueing behavior and performance 135 * not depend upon such differences. 136 */ 137#define _SK_MEM_PACKETS 256 138#define _SK_MEM_OVERHEAD (sizeof(struct sk_buff) + 256) 139#define SK_WMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS) 140#define SK_RMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS) 141 142/* Run time adjustable parameters. */ 143__u32 sysctl_wmem_max = SK_WMEM_MAX; 144__u32 sysctl_rmem_max = SK_RMEM_MAX; 145__u32 sysctl_wmem_default = SK_WMEM_MAX; 146__u32 sysctl_rmem_default = SK_RMEM_MAX; 147 148/* Maximal space eaten by iovec or ancilliary data plus some space */ 149int sysctl_optmem_max = sizeof(unsigned long)*(2*UIO_MAXIOV + 512); 150 151static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen) 152{ 153 struct timeval tv; 154 155 if (optlen < sizeof(tv)) 156 return -EINVAL; 157 if (copy_from_user(&tv, optval, sizeof(tv))) 158 return -EFAULT; 159 160 *timeo_p = MAX_SCHEDULE_TIMEOUT; 161 if (tv.tv_sec == 0 && tv.tv_usec == 0) 162 return 0; 163 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1)) 164 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ); 165 return 0; 166} 167 168static void sock_warn_obsolete_bsdism(const char *name) 169{ 170 static int warned; 171 static char warncomm[TASK_COMM_LEN]; 172 if (strcmp(warncomm, current->comm) && warned < 5) { 173 strcpy(warncomm, current->comm); 174 printk(KERN_WARNING "process `%s' is using obsolete " 175 "%s SO_BSDCOMPAT\n", warncomm, name); 176 warned++; 177 } 178} 179 180static void sock_disable_timestamp(struct sock *sk) 181{ 182 if (sock_flag(sk, SOCK_TIMESTAMP)) { 183 sock_reset_flag(sk, SOCK_TIMESTAMP); 184 net_disable_timestamp(); 185 } 186} 187 188 189/* 190 * This is meant for all protocols to use and covers goings on 191 * at the socket level. Everything here is generic. 192 */ 193 194int sock_setsockopt(struct socket *sock, int level, int optname, 195 char __user *optval, int optlen) 196{ 197 struct sock *sk=sock->sk; 198 struct sk_filter *filter; 199 int val; 200 int valbool; 201 struct linger ling; 202 int ret = 0; 203 204 /* 205 * Options without arguments 206 */ 207 208#ifdef SO_DONTLINGER /* Compatibility item... */ 209 if (optname == SO_DONTLINGER) { 210 lock_sock(sk); 211 sock_reset_flag(sk, SOCK_LINGER); 212 release_sock(sk); 213 return 0; 214 } 215#endif 216 217 if(optlen<sizeof(int)) 218 return(-EINVAL); 219 220 if (get_user(val, (int __user *)optval)) 221 return -EFAULT; 222 223 valbool = val?1:0; 224 225 lock_sock(sk); 226 227 switch(optname) 228 { 229 case SO_DEBUG: 230 if(val && !capable(CAP_NET_ADMIN)) 231 { 232 ret = -EACCES; 233 } 234 else if (valbool) 235 sock_set_flag(sk, SOCK_DBG); 236 else 237 sock_reset_flag(sk, SOCK_DBG); 238 break; 239 case SO_REUSEADDR: 240 sk->sk_reuse = valbool; 241 break; 242 case SO_TYPE: 243 case SO_ERROR: 244 ret = -ENOPROTOOPT; 245 break; 246 case SO_DONTROUTE: 247 if (valbool) 248 sock_set_flag(sk, SOCK_LOCALROUTE); 249 else 250 sock_reset_flag(sk, SOCK_LOCALROUTE); 251 break; 252 case SO_BROADCAST: 253 sock_valbool_flag(sk, SOCK_BROADCAST, valbool); 254 break; 255 case SO_SNDBUF: 256 /* Don't error on this BSD doesn't and if you think 257 about it this is right. Otherwise apps have to 258 play 'guess the biggest size' games. RCVBUF/SNDBUF 259 are treated in BSD as hints */ 260 261 if (val > sysctl_wmem_max) 262 val = sysctl_wmem_max; 263set_sndbuf: 264 sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 265 if ((val * 2) < SOCK_MIN_SNDBUF) 266 sk->sk_sndbuf = SOCK_MIN_SNDBUF; 267 else 268 sk->sk_sndbuf = val * 2; 269 270 /* 271 * Wake up sending tasks if we 272 * upped the value. 273 */ 274 sk->sk_write_space(sk); 275 break; 276 277 case SO_SNDBUFFORCE: 278 if (!capable(CAP_NET_ADMIN)) { 279 ret = -EPERM; 280 break; 281 } 282 goto set_sndbuf; 283 284 case SO_RCVBUF: 285 /* Don't error on this BSD doesn't and if you think 286 about it this is right. Otherwise apps have to 287 play 'guess the biggest size' games. RCVBUF/SNDBUF 288 are treated in BSD as hints */ 289 290 if (val > sysctl_rmem_max) 291 val = sysctl_rmem_max; 292set_rcvbuf: 293 sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 294 /* FIXME: is this lower bound the right one? */ 295 if ((val * 2) < SOCK_MIN_RCVBUF) 296 sk->sk_rcvbuf = SOCK_MIN_RCVBUF; 297 else 298 sk->sk_rcvbuf = val * 2; 299 break; 300 301 case SO_RCVBUFFORCE: 302 if (!capable(CAP_NET_ADMIN)) { 303 ret = -EPERM; 304 break; 305 } 306 goto set_rcvbuf; 307 308 case SO_KEEPALIVE: 309#ifdef CONFIG_INET 310 if (sk->sk_protocol == IPPROTO_TCP) 311 tcp_set_keepalive(sk, valbool); 312#endif 313 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool); 314 break; 315 316 case SO_OOBINLINE: 317 sock_valbool_flag(sk, SOCK_URGINLINE, valbool); 318 break; 319 320 case SO_NO_CHECK: 321 sk->sk_no_check = valbool; 322 break; 323 324 case SO_PRIORITY: 325 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN)) 326 sk->sk_priority = val; 327 else 328 ret = -EPERM; 329 break; 330 331 case SO_LINGER: 332 if(optlen<sizeof(ling)) { 333 ret = -EINVAL; /* 1003.1g */ 334 break; 335 } 336 if (copy_from_user(&ling,optval,sizeof(ling))) { 337 ret = -EFAULT; 338 break; 339 } 340 if (!ling.l_onoff) 341 sock_reset_flag(sk, SOCK_LINGER); 342 else { 343#if (BITS_PER_LONG == 32) 344 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ) 345 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT; 346 else 347#endif 348 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ; 349 sock_set_flag(sk, SOCK_LINGER); 350 } 351 break; 352 353 case SO_BSDCOMPAT: 354 sock_warn_obsolete_bsdism("setsockopt"); 355 break; 356 357 case SO_PASSCRED: 358 if (valbool) 359 set_bit(SOCK_PASSCRED, &sock->flags); 360 else 361 clear_bit(SOCK_PASSCRED, &sock->flags); 362 break; 363 364 case SO_TIMESTAMP: 365 if (valbool) { 366 sock_set_flag(sk, SOCK_RCVTSTAMP); 367 sock_enable_timestamp(sk); 368 } else 369 sock_reset_flag(sk, SOCK_RCVTSTAMP); 370 break; 371 372 case SO_RCVLOWAT: 373 if (val < 0) 374 val = INT_MAX; 375 sk->sk_rcvlowat = val ? : 1; 376 break; 377 378 case SO_RCVTIMEO: 379 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen); 380 break; 381 382 case SO_SNDTIMEO: 383 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen); 384 break; 385 386#ifdef CONFIG_NETDEVICES 387 case SO_BINDTODEVICE: 388 { 389 char devname[IFNAMSIZ]; 390 391 /* Sorry... */ 392 if (!capable(CAP_NET_RAW)) { 393 ret = -EPERM; 394 break; 395 } 396 397 /* Bind this socket to a particular device like "eth0", 398 * as specified in the passed interface name. If the 399 * name is "" or the option length is zero the socket 400 * is not bound. 401 */ 402 403 if (!valbool) { 404 sk->sk_bound_dev_if = 0; 405 } else { 406 if (optlen > IFNAMSIZ) 407 optlen = IFNAMSIZ; 408 if (copy_from_user(devname, optval, optlen)) { 409 ret = -EFAULT; 410 break; 411 } 412 413 /* Remove any cached route for this socket. */ 414 sk_dst_reset(sk); 415 416 if (devname[0] == '\0') { 417 sk->sk_bound_dev_if = 0; 418 } else { 419 struct net_device *dev = dev_get_by_name(devname); 420 if (!dev) { 421 ret = -ENODEV; 422 break; 423 } 424 sk->sk_bound_dev_if = dev->ifindex; 425 dev_put(dev); 426 } 427 } 428 break; 429 } 430#endif 431 432 433 case SO_ATTACH_FILTER: 434 ret = -EINVAL; 435 if (optlen == sizeof(struct sock_fprog)) { 436 struct sock_fprog fprog; 437 438 ret = -EFAULT; 439 if (copy_from_user(&fprog, optval, sizeof(fprog))) 440 break; 441 442 ret = sk_attach_filter(&fprog, sk); 443 } 444 break; 445 446 case SO_DETACH_FILTER: 447 spin_lock_bh(&sk->sk_lock.slock); 448 filter = sk->sk_filter; 449 if (filter) { 450 sk->sk_filter = NULL; 451 spin_unlock_bh(&sk->sk_lock.slock); 452 sk_filter_release(sk, filter); 453 break; 454 } 455 spin_unlock_bh(&sk->sk_lock.slock); 456 ret = -ENONET; 457 break; 458 459 /* We implement the SO_SNDLOWAT etc to 460 not be settable (1003.1g 5.3) */ 461 default: 462 ret = -ENOPROTOOPT; 463 break; 464 } 465 release_sock(sk); 466 return ret; 467} 468 469 470int sock_getsockopt(struct socket *sock, int level, int optname, 471 char __user *optval, int __user *optlen) 472{ 473 struct sock *sk = sock->sk; 474 475 union 476 { 477 int val; 478 struct linger ling; 479 struct timeval tm; 480 } v; 481 482 unsigned int lv = sizeof(int); 483 int len; 484 485 if(get_user(len,optlen)) 486 return -EFAULT; 487 if(len < 0) 488 return -EINVAL; 489 490 switch(optname) 491 { 492 case SO_DEBUG: 493 v.val = sock_flag(sk, SOCK_DBG); 494 break; 495 496 case SO_DONTROUTE: 497 v.val = sock_flag(sk, SOCK_LOCALROUTE); 498 break; 499 500 case SO_BROADCAST: 501 v.val = !!sock_flag(sk, SOCK_BROADCAST); 502 break; 503 504 case SO_SNDBUF: 505 v.val = sk->sk_sndbuf; 506 break; 507 508 case SO_RCVBUF: 509 v.val = sk->sk_rcvbuf; 510 break; 511 512 case SO_REUSEADDR: 513 v.val = sk->sk_reuse; 514 break; 515 516 case SO_KEEPALIVE: 517 v.val = !!sock_flag(sk, SOCK_KEEPOPEN); 518 break; 519 520 case SO_TYPE: 521 v.val = sk->sk_type; 522 break; 523 524 case SO_ERROR: 525 v.val = -sock_error(sk); 526 if(v.val==0) 527 v.val = xchg(&sk->sk_err_soft, 0); 528 break; 529 530 case SO_OOBINLINE: 531 v.val = !!sock_flag(sk, SOCK_URGINLINE); 532 break; 533 534 case SO_NO_CHECK: 535 v.val = sk->sk_no_check; 536 break; 537 538 case SO_PRIORITY: 539 v.val = sk->sk_priority; 540 break; 541 542 case SO_LINGER: 543 lv = sizeof(v.ling); 544 v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER); 545 v.ling.l_linger = sk->sk_lingertime / HZ; 546 break; 547 548 case SO_BSDCOMPAT: 549 sock_warn_obsolete_bsdism("getsockopt"); 550 break; 551 552 case SO_TIMESTAMP: 553 v.val = sock_flag(sk, SOCK_RCVTSTAMP); 554 break; 555 556 case SO_RCVTIMEO: 557 lv=sizeof(struct timeval); 558 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) { 559 v.tm.tv_sec = 0; 560 v.tm.tv_usec = 0; 561 } else { 562 v.tm.tv_sec = sk->sk_rcvtimeo / HZ; 563 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ; 564 } 565 break; 566 567 case SO_SNDTIMEO: 568 lv=sizeof(struct timeval); 569 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) { 570 v.tm.tv_sec = 0; 571 v.tm.tv_usec = 0; 572 } else { 573 v.tm.tv_sec = sk->sk_sndtimeo / HZ; 574 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ; 575 } 576 break; 577 578 case SO_RCVLOWAT: 579 v.val = sk->sk_rcvlowat; 580 break; 581 582 case SO_SNDLOWAT: 583 v.val=1; 584 break; 585 586 case SO_PASSCRED: 587 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0; 588 break; 589 590 case SO_PEERCRED: 591 if (len > sizeof(sk->sk_peercred)) 592 len = sizeof(sk->sk_peercred); 593 if (copy_to_user(optval, &sk->sk_peercred, len)) 594 return -EFAULT; 595 goto lenout; 596 597 case SO_PEERNAME: 598 { 599 char address[128]; 600 601 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2)) 602 return -ENOTCONN; 603 if (lv < len) 604 return -EINVAL; 605 if (copy_to_user(optval, address, len)) 606 return -EFAULT; 607 goto lenout; 608 } 609 610 /* Dubious BSD thing... Probably nobody even uses it, but 611 * the UNIX standard wants it for whatever reason... -DaveM 612 */ 613 case SO_ACCEPTCONN: 614 v.val = sk->sk_state == TCP_LISTEN; 615 break; 616 617 case SO_PEERSEC: 618 return security_socket_getpeersec(sock, optval, optlen, len); 619 620 default: 621 return(-ENOPROTOOPT); 622 } 623 if (len > lv) 624 len = lv; 625 if (copy_to_user(optval, &v, len)) 626 return -EFAULT; 627lenout: 628 if (put_user(len, optlen)) 629 return -EFAULT; 630 return 0; 631} 632 633/** 634 * sk_alloc - All socket objects are allocated here 635 * @family: protocol family 636 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc) 637 * @prot: struct proto associated with this new sock instance 638 * @zero_it: if we should zero the newly allocated sock 639 */ 640struct sock *sk_alloc(int family, gfp_t priority, 641 struct proto *prot, int zero_it) 642{ 643 struct sock *sk = NULL; 644 kmem_cache_t *slab = prot->slab; 645 646 if (slab != NULL) 647 sk = kmem_cache_alloc(slab, priority); 648 else 649 sk = kmalloc(prot->obj_size, priority); 650 651 if (sk) { 652 if (zero_it) { 653 memset(sk, 0, prot->obj_size); 654 sk->sk_family = family; 655 /* 656 * See comment in struct sock definition to understand 657 * why we need sk_prot_creator -acme 658 */ 659 sk->sk_prot = sk->sk_prot_creator = prot; 660 sock_lock_init(sk); 661 } 662 663 if (security_sk_alloc(sk, family, priority)) 664 goto out_free; 665 666 if (!try_module_get(prot->owner)) 667 goto out_free; 668 } 669 return sk; 670 671out_free: 672 if (slab != NULL) 673 kmem_cache_free(slab, sk); 674 else 675 kfree(sk); 676 return NULL; 677} 678 679void sk_free(struct sock *sk) 680{ 681 struct sk_filter *filter; 682 struct module *owner = sk->sk_prot_creator->owner; 683 684 if (sk->sk_destruct) 685 sk->sk_destruct(sk); 686 687 filter = sk->sk_filter; 688 if (filter) { 689 sk_filter_release(sk, filter); 690 sk->sk_filter = NULL; 691 } 692 693 sock_disable_timestamp(sk); 694 695 if (atomic_read(&sk->sk_omem_alloc)) 696 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n", 697 __FUNCTION__, atomic_read(&sk->sk_omem_alloc)); 698 699 security_sk_free(sk); 700 if (sk->sk_prot_creator->slab != NULL) 701 kmem_cache_free(sk->sk_prot_creator->slab, sk); 702 else 703 kfree(sk); 704 module_put(owner); 705} 706 707struct sock *sk_clone(const struct sock *sk, const gfp_t priority) 708{ 709 struct sock *newsk = sk_alloc(sk->sk_family, priority, sk->sk_prot, 0); 710 711 if (newsk != NULL) { 712 struct sk_filter *filter; 713 714 memcpy(newsk, sk, sk->sk_prot->obj_size); 715 716 /* SANITY */ 717 sk_node_init(&newsk->sk_node); 718 sock_lock_init(newsk); 719 bh_lock_sock(newsk); 720 721 atomic_set(&newsk->sk_rmem_alloc, 0); 722 atomic_set(&newsk->sk_wmem_alloc, 0); 723 atomic_set(&newsk->sk_omem_alloc, 0); 724 skb_queue_head_init(&newsk->sk_receive_queue); 725 skb_queue_head_init(&newsk->sk_write_queue); 726 727 rwlock_init(&newsk->sk_dst_lock); 728 rwlock_init(&newsk->sk_callback_lock); 729 730 newsk->sk_dst_cache = NULL; 731 newsk->sk_wmem_queued = 0; 732 newsk->sk_forward_alloc = 0; 733 newsk->sk_send_head = NULL; 734 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL; 735 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK; 736 737 sock_reset_flag(newsk, SOCK_DONE); 738 skb_queue_head_init(&newsk->sk_error_queue); 739 740 filter = newsk->sk_filter; 741 if (filter != NULL) 742 sk_filter_charge(newsk, filter); 743 744 if (unlikely(xfrm_sk_clone_policy(newsk))) { 745 /* It is still raw copy of parent, so invalidate 746 * destructor and make plain sk_free() */ 747 newsk->sk_destruct = NULL; 748 sk_free(newsk); 749 newsk = NULL; 750 goto out; 751 } 752 753 newsk->sk_err = 0; 754 newsk->sk_priority = 0; 755 atomic_set(&newsk->sk_refcnt, 2); 756 757 /* 758 * Increment the counter in the same struct proto as the master 759 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that 760 * is the same as sk->sk_prot->socks, as this field was copied 761 * with memcpy). 762 * 763 * This _changes_ the previous behaviour, where 764 * tcp_create_openreq_child always was incrementing the 765 * equivalent to tcp_prot->socks (inet_sock_nr), so this have 766 * to be taken into account in all callers. -acme 767 */ 768 sk_refcnt_debug_inc(newsk); 769 newsk->sk_socket = NULL; 770 newsk->sk_sleep = NULL; 771 772 if (newsk->sk_prot->sockets_allocated) 773 atomic_inc(newsk->sk_prot->sockets_allocated); 774 } 775out: 776 return newsk; 777} 778 779EXPORT_SYMBOL_GPL(sk_clone); 780 781void __init sk_init(void) 782{ 783 if (num_physpages <= 4096) { 784 sysctl_wmem_max = 32767; 785 sysctl_rmem_max = 32767; 786 sysctl_wmem_default = 32767; 787 sysctl_rmem_default = 32767; 788 } else if (num_physpages >= 131072) { 789 sysctl_wmem_max = 131071; 790 sysctl_rmem_max = 131071; 791 } 792} 793 794/* 795 * Simple resource managers for sockets. 796 */ 797 798 799/* 800 * Write buffer destructor automatically called from kfree_skb. 801 */ 802void sock_wfree(struct sk_buff *skb) 803{ 804 struct sock *sk = skb->sk; 805 806 /* In case it might be waiting for more memory. */ 807 atomic_sub(skb->truesize, &sk->sk_wmem_alloc); 808 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) 809 sk->sk_write_space(sk); 810 sock_put(sk); 811} 812 813/* 814 * Read buffer destructor automatically called from kfree_skb. 815 */ 816void sock_rfree(struct sk_buff *skb) 817{ 818 struct sock *sk = skb->sk; 819 820 atomic_sub(skb->truesize, &sk->sk_rmem_alloc); 821} 822 823 824int sock_i_uid(struct sock *sk) 825{ 826 int uid; 827 828 read_lock(&sk->sk_callback_lock); 829 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0; 830 read_unlock(&sk->sk_callback_lock); 831 return uid; 832} 833 834unsigned long sock_i_ino(struct sock *sk) 835{ 836 unsigned long ino; 837 838 read_lock(&sk->sk_callback_lock); 839 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0; 840 read_unlock(&sk->sk_callback_lock); 841 return ino; 842} 843 844/* 845 * Allocate a skb from the socket's send buffer. 846 */ 847struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, 848 gfp_t priority) 849{ 850 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) { 851 struct sk_buff * skb = alloc_skb(size, priority); 852 if (skb) { 853 skb_set_owner_w(skb, sk); 854 return skb; 855 } 856 } 857 return NULL; 858} 859 860/* 861 * Allocate a skb from the socket's receive buffer. 862 */ 863struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, 864 gfp_t priority) 865{ 866 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) { 867 struct sk_buff *skb = alloc_skb(size, priority); 868 if (skb) { 869 skb_set_owner_r(skb, sk); 870 return skb; 871 } 872 } 873 return NULL; 874} 875 876/* 877 * Allocate a memory block from the socket's option memory buffer. 878 */ 879void *sock_kmalloc(struct sock *sk, int size, gfp_t priority) 880{ 881 if ((unsigned)size <= sysctl_optmem_max && 882 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) { 883 void *mem; 884 /* First do the add, to avoid the race if kmalloc 885 * might sleep. 886 */ 887 atomic_add(size, &sk->sk_omem_alloc); 888 mem = kmalloc(size, priority); 889 if (mem) 890 return mem; 891 atomic_sub(size, &sk->sk_omem_alloc); 892 } 893 return NULL; 894} 895 896/* 897 * Free an option memory block. 898 */ 899void sock_kfree_s(struct sock *sk, void *mem, int size) 900{ 901 kfree(mem); 902 atomic_sub(size, &sk->sk_omem_alloc); 903} 904 905/* It is almost wait_for_tcp_memory minus release_sock/lock_sock. 906 I think, these locks should be removed for datagram sockets. 907 */ 908static long sock_wait_for_wmem(struct sock * sk, long timeo) 909{ 910 DEFINE_WAIT(wait); 911 912 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 913 for (;;) { 914 if (!timeo) 915 break; 916 if (signal_pending(current)) 917 break; 918 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); 919 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 920 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) 921 break; 922 if (sk->sk_shutdown & SEND_SHUTDOWN) 923 break; 924 if (sk->sk_err) 925 break; 926 timeo = schedule_timeout(timeo); 927 } 928 finish_wait(sk->sk_sleep, &wait); 929 return timeo; 930} 931 932 933/* 934 * Generic send/receive buffer handlers 935 */ 936 937static struct sk_buff *sock_alloc_send_pskb(struct sock *sk, 938 unsigned long header_len, 939 unsigned long data_len, 940 int noblock, int *errcode) 941{ 942 struct sk_buff *skb; 943 gfp_t gfp_mask; 944 long timeo; 945 int err; 946 947 gfp_mask = sk->sk_allocation; 948 if (gfp_mask & __GFP_WAIT) 949 gfp_mask |= __GFP_REPEAT; 950 951 timeo = sock_sndtimeo(sk, noblock); 952 while (1) { 953 err = sock_error(sk); 954 if (err != 0) 955 goto failure; 956 957 err = -EPIPE; 958 if (sk->sk_shutdown & SEND_SHUTDOWN) 959 goto failure; 960 961 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) { 962 skb = alloc_skb(header_len, sk->sk_allocation); 963 if (skb) { 964 int npages; 965 int i; 966 967 /* No pages, we're done... */ 968 if (!data_len) 969 break; 970 971 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT; 972 skb->truesize += data_len; 973 skb_shinfo(skb)->nr_frags = npages; 974 for (i = 0; i < npages; i++) { 975 struct page *page; 976 skb_frag_t *frag; 977 978 page = alloc_pages(sk->sk_allocation, 0); 979 if (!page) { 980 err = -ENOBUFS; 981 skb_shinfo(skb)->nr_frags = i; 982 kfree_skb(skb); 983 goto failure; 984 } 985 986 frag = &skb_shinfo(skb)->frags[i]; 987 frag->page = page; 988 frag->page_offset = 0; 989 frag->size = (data_len >= PAGE_SIZE ? 990 PAGE_SIZE : 991 data_len); 992 data_len -= PAGE_SIZE; 993 } 994 995 /* Full success... */ 996 break; 997 } 998 err = -ENOBUFS; 999 goto failure; 1000 } 1001 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 1002 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); 1003 err = -EAGAIN; 1004 if (!timeo) 1005 goto failure; 1006 if (signal_pending(current)) 1007 goto interrupted; 1008 timeo = sock_wait_for_wmem(sk, timeo); 1009 } 1010 1011 skb_set_owner_w(skb, sk); 1012 return skb; 1013 1014interrupted: 1015 err = sock_intr_errno(timeo); 1016failure: 1017 *errcode = err; 1018 return NULL; 1019} 1020 1021struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, 1022 int noblock, int *errcode) 1023{ 1024 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode); 1025} 1026 1027static void __lock_sock(struct sock *sk) 1028{ 1029 DEFINE_WAIT(wait); 1030 1031 for(;;) { 1032 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait, 1033 TASK_UNINTERRUPTIBLE); 1034 spin_unlock_bh(&sk->sk_lock.slock); 1035 schedule(); 1036 spin_lock_bh(&sk->sk_lock.slock); 1037 if(!sock_owned_by_user(sk)) 1038 break; 1039 } 1040 finish_wait(&sk->sk_lock.wq, &wait); 1041} 1042 1043static void __release_sock(struct sock *sk) 1044{ 1045 struct sk_buff *skb = sk->sk_backlog.head; 1046 1047 do { 1048 sk->sk_backlog.head = sk->sk_backlog.tail = NULL; 1049 bh_unlock_sock(sk); 1050 1051 do { 1052 struct sk_buff *next = skb->next; 1053 1054 skb->next = NULL; 1055 sk->sk_backlog_rcv(sk, skb); 1056 1057 /* 1058 * We are in process context here with softirqs 1059 * disabled, use cond_resched_softirq() to preempt. 1060 * This is safe to do because we've taken the backlog 1061 * queue private: 1062 */ 1063 cond_resched_softirq(); 1064 1065 skb = next; 1066 } while (skb != NULL); 1067 1068 bh_lock_sock(sk); 1069 } while((skb = sk->sk_backlog.head) != NULL); 1070} 1071 1072/** 1073 * sk_wait_data - wait for data to arrive at sk_receive_queue 1074 * @sk: sock to wait on 1075 * @timeo: for how long 1076 * 1077 * Now socket state including sk->sk_err is changed only under lock, 1078 * hence we may omit checks after joining wait queue. 1079 * We check receive queue before schedule() only as optimization; 1080 * it is very likely that release_sock() added new data. 1081 */ 1082int sk_wait_data(struct sock *sk, long *timeo) 1083{ 1084 int rc; 1085 DEFINE_WAIT(wait); 1086 1087 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 1088 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 1089 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue)); 1090 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 1091 finish_wait(sk->sk_sleep, &wait); 1092 return rc; 1093} 1094 1095EXPORT_SYMBOL(sk_wait_data); 1096 1097/* 1098 * Set of default routines for initialising struct proto_ops when 1099 * the protocol does not support a particular function. In certain 1100 * cases where it makes no sense for a protocol to have a "do nothing" 1101 * function, some default processing is provided. 1102 */ 1103 1104int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len) 1105{ 1106 return -EOPNOTSUPP; 1107} 1108 1109int sock_no_connect(struct socket *sock, struct sockaddr *saddr, 1110 int len, int flags) 1111{ 1112 return -EOPNOTSUPP; 1113} 1114 1115int sock_no_socketpair(struct socket *sock1, struct socket *sock2) 1116{ 1117 return -EOPNOTSUPP; 1118} 1119 1120int sock_no_accept(struct socket *sock, struct socket *newsock, int flags) 1121{ 1122 return -EOPNOTSUPP; 1123} 1124 1125int sock_no_getname(struct socket *sock, struct sockaddr *saddr, 1126 int *len, int peer) 1127{ 1128 return -EOPNOTSUPP; 1129} 1130 1131unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt) 1132{ 1133 return 0; 1134} 1135 1136int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1137{ 1138 return -EOPNOTSUPP; 1139} 1140 1141int sock_no_listen(struct socket *sock, int backlog) 1142{ 1143 return -EOPNOTSUPP; 1144} 1145 1146int sock_no_shutdown(struct socket *sock, int how) 1147{ 1148 return -EOPNOTSUPP; 1149} 1150 1151int sock_no_setsockopt(struct socket *sock, int level, int optname, 1152 char __user *optval, int optlen) 1153{ 1154 return -EOPNOTSUPP; 1155} 1156 1157int sock_no_getsockopt(struct socket *sock, int level, int optname, 1158 char __user *optval, int __user *optlen) 1159{ 1160 return -EOPNOTSUPP; 1161} 1162 1163int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m, 1164 size_t len) 1165{ 1166 return -EOPNOTSUPP; 1167} 1168 1169int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m, 1170 size_t len, int flags) 1171{ 1172 return -EOPNOTSUPP; 1173} 1174 1175int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma) 1176{ 1177 /* Mirror missing mmap method error code */ 1178 return -ENODEV; 1179} 1180 1181ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags) 1182{ 1183 ssize_t res; 1184 struct msghdr msg = {.msg_flags = flags}; 1185 struct kvec iov; 1186 char *kaddr = kmap(page); 1187 iov.iov_base = kaddr + offset; 1188 iov.iov_len = size; 1189 res = kernel_sendmsg(sock, &msg, &iov, 1, size); 1190 kunmap(page); 1191 return res; 1192} 1193 1194/* 1195 * Default Socket Callbacks 1196 */ 1197 1198static void sock_def_wakeup(struct sock *sk) 1199{ 1200 read_lock(&sk->sk_callback_lock); 1201 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1202 wake_up_interruptible_all(sk->sk_sleep); 1203 read_unlock(&sk->sk_callback_lock); 1204} 1205 1206static void sock_def_error_report(struct sock *sk) 1207{ 1208 read_lock(&sk->sk_callback_lock); 1209 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1210 wake_up_interruptible(sk->sk_sleep); 1211 sk_wake_async(sk,0,POLL_ERR); 1212 read_unlock(&sk->sk_callback_lock); 1213} 1214 1215static void sock_def_readable(struct sock *sk, int len) 1216{ 1217 read_lock(&sk->sk_callback_lock); 1218 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1219 wake_up_interruptible(sk->sk_sleep); 1220 sk_wake_async(sk,1,POLL_IN); 1221 read_unlock(&sk->sk_callback_lock); 1222} 1223 1224static void sock_def_write_space(struct sock *sk) 1225{ 1226 read_lock(&sk->sk_callback_lock); 1227 1228 /* Do not wake up a writer until he can make "significant" 1229 * progress. --DaveM 1230 */ 1231 if((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) { 1232 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1233 wake_up_interruptible(sk->sk_sleep); 1234 1235 /* Should agree with poll, otherwise some programs break */ 1236 if (sock_writeable(sk)) 1237 sk_wake_async(sk, 2, POLL_OUT); 1238 } 1239 1240 read_unlock(&sk->sk_callback_lock); 1241} 1242 1243static void sock_def_destruct(struct sock *sk) 1244{ 1245 kfree(sk->sk_protinfo); 1246} 1247 1248void sk_send_sigurg(struct sock *sk) 1249{ 1250 if (sk->sk_socket && sk->sk_socket->file) 1251 if (send_sigurg(&sk->sk_socket->file->f_owner)) 1252 sk_wake_async(sk, 3, POLL_PRI); 1253} 1254 1255void sk_reset_timer(struct sock *sk, struct timer_list* timer, 1256 unsigned long expires) 1257{ 1258 if (!mod_timer(timer, expires)) 1259 sock_hold(sk); 1260} 1261 1262EXPORT_SYMBOL(sk_reset_timer); 1263 1264void sk_stop_timer(struct sock *sk, struct timer_list* timer) 1265{ 1266 if (timer_pending(timer) && del_timer(timer)) 1267 __sock_put(sk); 1268} 1269 1270EXPORT_SYMBOL(sk_stop_timer); 1271 1272void sock_init_data(struct socket *sock, struct sock *sk) 1273{ 1274 skb_queue_head_init(&sk->sk_receive_queue); 1275 skb_queue_head_init(&sk->sk_write_queue); 1276 skb_queue_head_init(&sk->sk_error_queue); 1277 1278 sk->sk_send_head = NULL; 1279 1280 init_timer(&sk->sk_timer); 1281 1282 sk->sk_allocation = GFP_KERNEL; 1283 sk->sk_rcvbuf = sysctl_rmem_default; 1284 sk->sk_sndbuf = sysctl_wmem_default; 1285 sk->sk_state = TCP_CLOSE; 1286 sk->sk_socket = sock; 1287 1288 sock_set_flag(sk, SOCK_ZAPPED); 1289 1290 if(sock) 1291 { 1292 sk->sk_type = sock->type; 1293 sk->sk_sleep = &sock->wait; 1294 sock->sk = sk; 1295 } else 1296 sk->sk_sleep = NULL; 1297 1298 rwlock_init(&sk->sk_dst_lock); 1299 rwlock_init(&sk->sk_callback_lock); 1300 1301 sk->sk_state_change = sock_def_wakeup; 1302 sk->sk_data_ready = sock_def_readable; 1303 sk->sk_write_space = sock_def_write_space; 1304 sk->sk_error_report = sock_def_error_report; 1305 sk->sk_destruct = sock_def_destruct; 1306 1307 sk->sk_sndmsg_page = NULL; 1308 sk->sk_sndmsg_off = 0; 1309 1310 sk->sk_peercred.pid = 0; 1311 sk->sk_peercred.uid = -1; 1312 sk->sk_peercred.gid = -1; 1313 sk->sk_write_pending = 0; 1314 sk->sk_rcvlowat = 1; 1315 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1316 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT; 1317 1318 sk->sk_stamp.tv_sec = -1L; 1319 sk->sk_stamp.tv_usec = -1L; 1320 1321 atomic_set(&sk->sk_refcnt, 1); 1322} 1323 1324void fastcall lock_sock(struct sock *sk) 1325{ 1326 might_sleep(); 1327 spin_lock_bh(&(sk->sk_lock.slock)); 1328 if (sk->sk_lock.owner) 1329 __lock_sock(sk); 1330 sk->sk_lock.owner = (void *)1; 1331 spin_unlock_bh(&(sk->sk_lock.slock)); 1332} 1333 1334EXPORT_SYMBOL(lock_sock); 1335 1336void fastcall release_sock(struct sock *sk) 1337{ 1338 spin_lock_bh(&(sk->sk_lock.slock)); 1339 if (sk->sk_backlog.tail) 1340 __release_sock(sk); 1341 sk->sk_lock.owner = NULL; 1342 if (waitqueue_active(&(sk->sk_lock.wq))) 1343 wake_up(&(sk->sk_lock.wq)); 1344 spin_unlock_bh(&(sk->sk_lock.slock)); 1345} 1346EXPORT_SYMBOL(release_sock); 1347 1348int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp) 1349{ 1350 if (!sock_flag(sk, SOCK_TIMESTAMP)) 1351 sock_enable_timestamp(sk); 1352 if (sk->sk_stamp.tv_sec == -1) 1353 return -ENOENT; 1354 if (sk->sk_stamp.tv_sec == 0) 1355 do_gettimeofday(&sk->sk_stamp); 1356 return copy_to_user(userstamp, &sk->sk_stamp, sizeof(struct timeval)) ? 1357 -EFAULT : 0; 1358} 1359EXPORT_SYMBOL(sock_get_timestamp); 1360 1361void sock_enable_timestamp(struct sock *sk) 1362{ 1363 if (!sock_flag(sk, SOCK_TIMESTAMP)) { 1364 sock_set_flag(sk, SOCK_TIMESTAMP); 1365 net_enable_timestamp(); 1366 } 1367} 1368EXPORT_SYMBOL(sock_enable_timestamp); 1369 1370/* 1371 * Get a socket option on an socket. 1372 * 1373 * FIX: POSIX 1003.1g is very ambiguous here. It states that 1374 * asynchronous errors should be reported by getsockopt. We assume 1375 * this means if you specify SO_ERROR (otherwise whats the point of it). 1376 */ 1377int sock_common_getsockopt(struct socket *sock, int level, int optname, 1378 char __user *optval, int __user *optlen) 1379{ 1380 struct sock *sk = sock->sk; 1381 1382 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen); 1383} 1384 1385EXPORT_SYMBOL(sock_common_getsockopt); 1386 1387int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock, 1388 struct msghdr *msg, size_t size, int flags) 1389{ 1390 struct sock *sk = sock->sk; 1391 int addr_len = 0; 1392 int err; 1393 1394 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT, 1395 flags & ~MSG_DONTWAIT, &addr_len); 1396 if (err >= 0) 1397 msg->msg_namelen = addr_len; 1398 return err; 1399} 1400 1401EXPORT_SYMBOL(sock_common_recvmsg); 1402 1403/* 1404 * Set socket options on an inet socket. 1405 */ 1406int sock_common_setsockopt(struct socket *sock, int level, int optname, 1407 char __user *optval, int optlen) 1408{ 1409 struct sock *sk = sock->sk; 1410 1411 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen); 1412} 1413 1414EXPORT_SYMBOL(sock_common_setsockopt); 1415 1416void sk_common_release(struct sock *sk) 1417{ 1418 if (sk->sk_prot->destroy) 1419 sk->sk_prot->destroy(sk); 1420 1421 /* 1422 * Observation: when sock_common_release is called, processes have 1423 * no access to socket. But net still has. 1424 * Step one, detach it from networking: 1425 * 1426 * A. Remove from hash tables. 1427 */ 1428 1429 sk->sk_prot->unhash(sk); 1430 1431 /* 1432 * In this point socket cannot receive new packets, but it is possible 1433 * that some packets are in flight because some CPU runs receiver and 1434 * did hash table lookup before we unhashed socket. They will achieve 1435 * receive queue and will be purged by socket destructor. 1436 * 1437 * Also we still have packets pending on receive queue and probably, 1438 * our own packets waiting in device queues. sock_destroy will drain 1439 * receive queue, but transmitted packets will delay socket destruction 1440 * until the last reference will be released. 1441 */ 1442 1443 sock_orphan(sk); 1444 1445 xfrm_sk_free_policy(sk); 1446 1447 sk_refcnt_debug_release(sk); 1448 sock_put(sk); 1449} 1450 1451EXPORT_SYMBOL(sk_common_release); 1452 1453static DEFINE_RWLOCK(proto_list_lock); 1454static LIST_HEAD(proto_list); 1455 1456int proto_register(struct proto *prot, int alloc_slab) 1457{ 1458 char *request_sock_slab_name = NULL; 1459 char *timewait_sock_slab_name; 1460 int rc = -ENOBUFS; 1461 1462 if (alloc_slab) { 1463 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0, 1464 SLAB_HWCACHE_ALIGN, NULL, NULL); 1465 1466 if (prot->slab == NULL) { 1467 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n", 1468 prot->name); 1469 goto out; 1470 } 1471 1472 if (prot->rsk_prot != NULL) { 1473 static const char mask[] = "request_sock_%s"; 1474 1475 request_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL); 1476 if (request_sock_slab_name == NULL) 1477 goto out_free_sock_slab; 1478 1479 sprintf(request_sock_slab_name, mask, prot->name); 1480 prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name, 1481 prot->rsk_prot->obj_size, 0, 1482 SLAB_HWCACHE_ALIGN, NULL, NULL); 1483 1484 if (prot->rsk_prot->slab == NULL) { 1485 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n", 1486 prot->name); 1487 goto out_free_request_sock_slab_name; 1488 } 1489 } 1490 1491 if (prot->twsk_prot != NULL) { 1492 static const char mask[] = "tw_sock_%s"; 1493 1494 timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL); 1495 1496 if (timewait_sock_slab_name == NULL) 1497 goto out_free_request_sock_slab; 1498 1499 sprintf(timewait_sock_slab_name, mask, prot->name); 1500 prot->twsk_prot->twsk_slab = 1501 kmem_cache_create(timewait_sock_slab_name, 1502 prot->twsk_prot->twsk_obj_size, 1503 0, SLAB_HWCACHE_ALIGN, 1504 NULL, NULL); 1505 if (prot->twsk_prot->twsk_slab == NULL) 1506 goto out_free_timewait_sock_slab_name; 1507 } 1508 } 1509 1510 write_lock(&proto_list_lock); 1511 list_add(&prot->node, &proto_list); 1512 write_unlock(&proto_list_lock); 1513 rc = 0; 1514out: 1515 return rc; 1516out_free_timewait_sock_slab_name: 1517 kfree(timewait_sock_slab_name); 1518out_free_request_sock_slab: 1519 if (prot->rsk_prot && prot->rsk_prot->slab) { 1520 kmem_cache_destroy(prot->rsk_prot->slab); 1521 prot->rsk_prot->slab = NULL; 1522 } 1523out_free_request_sock_slab_name: 1524 kfree(request_sock_slab_name); 1525out_free_sock_slab: 1526 kmem_cache_destroy(prot->slab); 1527 prot->slab = NULL; 1528 goto out; 1529} 1530 1531EXPORT_SYMBOL(proto_register); 1532 1533void proto_unregister(struct proto *prot) 1534{ 1535 write_lock(&proto_list_lock); 1536 list_del(&prot->node); 1537 write_unlock(&proto_list_lock); 1538 1539 if (prot->slab != NULL) { 1540 kmem_cache_destroy(prot->slab); 1541 prot->slab = NULL; 1542 } 1543 1544 if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) { 1545 const char *name = kmem_cache_name(prot->rsk_prot->slab); 1546 1547 kmem_cache_destroy(prot->rsk_prot->slab); 1548 kfree(name); 1549 prot->rsk_prot->slab = NULL; 1550 } 1551 1552 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) { 1553 const char *name = kmem_cache_name(prot->twsk_prot->twsk_slab); 1554 1555 kmem_cache_destroy(prot->twsk_prot->twsk_slab); 1556 kfree(name); 1557 prot->twsk_prot->twsk_slab = NULL; 1558 } 1559} 1560 1561EXPORT_SYMBOL(proto_unregister); 1562 1563#ifdef CONFIG_PROC_FS 1564static inline struct proto *__proto_head(void) 1565{ 1566 return list_entry(proto_list.next, struct proto, node); 1567} 1568 1569static inline struct proto *proto_head(void) 1570{ 1571 return list_empty(&proto_list) ? NULL : __proto_head(); 1572} 1573 1574static inline struct proto *proto_next(struct proto *proto) 1575{ 1576 return proto->node.next == &proto_list ? NULL : 1577 list_entry(proto->node.next, struct proto, node); 1578} 1579 1580static inline struct proto *proto_get_idx(loff_t pos) 1581{ 1582 struct proto *proto; 1583 loff_t i = 0; 1584 1585 list_for_each_entry(proto, &proto_list, node) 1586 if (i++ == pos) 1587 goto out; 1588 1589 proto = NULL; 1590out: 1591 return proto; 1592} 1593 1594static void *proto_seq_start(struct seq_file *seq, loff_t *pos) 1595{ 1596 read_lock(&proto_list_lock); 1597 return *pos ? proto_get_idx(*pos - 1) : SEQ_START_TOKEN; 1598} 1599 1600static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1601{ 1602 ++*pos; 1603 return v == SEQ_START_TOKEN ? proto_head() : proto_next(v); 1604} 1605 1606static void proto_seq_stop(struct seq_file *seq, void *v) 1607{ 1608 read_unlock(&proto_list_lock); 1609} 1610 1611static char proto_method_implemented(const void *method) 1612{ 1613 return method == NULL ? 'n' : 'y'; 1614} 1615 1616static void proto_seq_printf(struct seq_file *seq, struct proto *proto) 1617{ 1618 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s " 1619 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n", 1620 proto->name, 1621 proto->obj_size, 1622 proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1, 1623 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1, 1624 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI", 1625 proto->max_header, 1626 proto->slab == NULL ? "no" : "yes", 1627 module_name(proto->owner), 1628 proto_method_implemented(proto->close), 1629 proto_method_implemented(proto->connect), 1630 proto_method_implemented(proto->disconnect), 1631 proto_method_implemented(proto->accept), 1632 proto_method_implemented(proto->ioctl), 1633 proto_method_implemented(proto->init), 1634 proto_method_implemented(proto->destroy), 1635 proto_method_implemented(proto->shutdown), 1636 proto_method_implemented(proto->setsockopt), 1637 proto_method_implemented(proto->getsockopt), 1638 proto_method_implemented(proto->sendmsg), 1639 proto_method_implemented(proto->recvmsg), 1640 proto_method_implemented(proto->sendpage), 1641 proto_method_implemented(proto->bind), 1642 proto_method_implemented(proto->backlog_rcv), 1643 proto_method_implemented(proto->hash), 1644 proto_method_implemented(proto->unhash), 1645 proto_method_implemented(proto->get_port), 1646 proto_method_implemented(proto->enter_memory_pressure)); 1647} 1648 1649static int proto_seq_show(struct seq_file *seq, void *v) 1650{ 1651 if (v == SEQ_START_TOKEN) 1652 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s", 1653 "protocol", 1654 "size", 1655 "sockets", 1656 "memory", 1657 "press", 1658 "maxhdr", 1659 "slab", 1660 "module", 1661 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n"); 1662 else 1663 proto_seq_printf(seq, v); 1664 return 0; 1665} 1666 1667static struct seq_operations proto_seq_ops = { 1668 .start = proto_seq_start, 1669 .next = proto_seq_next, 1670 .stop = proto_seq_stop, 1671 .show = proto_seq_show, 1672}; 1673 1674static int proto_seq_open(struct inode *inode, struct file *file) 1675{ 1676 return seq_open(file, &proto_seq_ops); 1677} 1678 1679static struct file_operations proto_seq_fops = { 1680 .owner = THIS_MODULE, 1681 .open = proto_seq_open, 1682 .read = seq_read, 1683 .llseek = seq_lseek, 1684 .release = seq_release, 1685}; 1686 1687static int __init proto_init(void) 1688{ 1689 /* register /proc/net/protocols */ 1690 return proc_net_fops_create("protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0; 1691} 1692 1693subsys_initcall(proto_init); 1694 1695#endif /* PROC_FS */ 1696 1697EXPORT_SYMBOL(sk_alloc); 1698EXPORT_SYMBOL(sk_free); 1699EXPORT_SYMBOL(sk_send_sigurg); 1700EXPORT_SYMBOL(sock_alloc_send_skb); 1701EXPORT_SYMBOL(sock_init_data); 1702EXPORT_SYMBOL(sock_kfree_s); 1703EXPORT_SYMBOL(sock_kmalloc); 1704EXPORT_SYMBOL(sock_no_accept); 1705EXPORT_SYMBOL(sock_no_bind); 1706EXPORT_SYMBOL(sock_no_connect); 1707EXPORT_SYMBOL(sock_no_getname); 1708EXPORT_SYMBOL(sock_no_getsockopt); 1709EXPORT_SYMBOL(sock_no_ioctl); 1710EXPORT_SYMBOL(sock_no_listen); 1711EXPORT_SYMBOL(sock_no_mmap); 1712EXPORT_SYMBOL(sock_no_poll); 1713EXPORT_SYMBOL(sock_no_recvmsg); 1714EXPORT_SYMBOL(sock_no_sendmsg); 1715EXPORT_SYMBOL(sock_no_sendpage); 1716EXPORT_SYMBOL(sock_no_setsockopt); 1717EXPORT_SYMBOL(sock_no_shutdown); 1718EXPORT_SYMBOL(sock_no_socketpair); 1719EXPORT_SYMBOL(sock_rfree); 1720EXPORT_SYMBOL(sock_setsockopt); 1721EXPORT_SYMBOL(sock_wfree); 1722EXPORT_SYMBOL(sock_wmalloc); 1723EXPORT_SYMBOL(sock_i_uid); 1724EXPORT_SYMBOL(sock_i_ino); 1725EXPORT_SYMBOL(sysctl_optmem_max); 1726#ifdef CONFIG_SYSCTL 1727EXPORT_SYMBOL(sysctl_rmem_max); 1728EXPORT_SYMBOL(sysctl_wmem_max); 1729#endif 1730