sock.c revision 17926a79320afa9b95df6b977b40cca6d8713cea
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/capability.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#include <linux/highmem.h> 115 116#include <asm/uaccess.h> 117#include <asm/system.h> 118 119#include <linux/netdevice.h> 120#include <net/protocol.h> 121#include <linux/skbuff.h> 122#include <net/request_sock.h> 123#include <net/sock.h> 124#include <net/xfrm.h> 125#include <linux/ipsec.h> 126 127#include <linux/filter.h> 128 129#ifdef CONFIG_INET 130#include <net/tcp.h> 131#endif 132 133/* 134 * Each address family might have different locking rules, so we have 135 * one slock key per address family: 136 */ 137static struct lock_class_key af_family_keys[AF_MAX]; 138static struct lock_class_key af_family_slock_keys[AF_MAX]; 139 140#ifdef CONFIG_DEBUG_LOCK_ALLOC 141/* 142 * Make lock validator output more readable. (we pre-construct these 143 * strings build-time, so that runtime initialization of socket 144 * locks is fast): 145 */ 146static const char *af_family_key_strings[AF_MAX+1] = { 147 "sk_lock-AF_UNSPEC", "sk_lock-AF_UNIX" , "sk_lock-AF_INET" , 148 "sk_lock-AF_AX25" , "sk_lock-AF_IPX" , "sk_lock-AF_APPLETALK", 149 "sk_lock-AF_NETROM", "sk_lock-AF_BRIDGE" , "sk_lock-AF_ATMPVC" , 150 "sk_lock-AF_X25" , "sk_lock-AF_INET6" , "sk_lock-AF_ROSE" , 151 "sk_lock-AF_DECnet", "sk_lock-AF_NETBEUI" , "sk_lock-AF_SECURITY" , 152 "sk_lock-AF_KEY" , "sk_lock-AF_NETLINK" , "sk_lock-AF_PACKET" , 153 "sk_lock-AF_ASH" , "sk_lock-AF_ECONET" , "sk_lock-AF_ATMSVC" , 154 "sk_lock-21" , "sk_lock-AF_SNA" , "sk_lock-AF_IRDA" , 155 "sk_lock-AF_PPPOX" , "sk_lock-AF_WANPIPE" , "sk_lock-AF_LLC" , 156 "sk_lock-27" , "sk_lock-28" , "sk_lock-29" , 157 "sk_lock-AF_TIPC" , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV" , 158 "sk_lock-AF_RXRPC" , "sk_lock-AF_MAX" 159}; 160static const char *af_family_slock_key_strings[AF_MAX+1] = { 161 "slock-AF_UNSPEC", "slock-AF_UNIX" , "slock-AF_INET" , 162 "slock-AF_AX25" , "slock-AF_IPX" , "slock-AF_APPLETALK", 163 "slock-AF_NETROM", "slock-AF_BRIDGE" , "slock-AF_ATMPVC" , 164 "slock-AF_X25" , "slock-AF_INET6" , "slock-AF_ROSE" , 165 "slock-AF_DECnet", "slock-AF_NETBEUI" , "slock-AF_SECURITY" , 166 "slock-AF_KEY" , "slock-AF_NETLINK" , "slock-AF_PACKET" , 167 "slock-AF_ASH" , "slock-AF_ECONET" , "slock-AF_ATMSVC" , 168 "slock-21" , "slock-AF_SNA" , "slock-AF_IRDA" , 169 "slock-AF_PPPOX" , "slock-AF_WANPIPE" , "slock-AF_LLC" , 170 "slock-27" , "slock-28" , "slock-29" , 171 "slock-AF_TIPC" , "slock-AF_BLUETOOTH", "slock-AF_IUCV" , 172 "slock-AF_RXRPC" , "slock-AF_MAX" 173}; 174#endif 175 176/* 177 * sk_callback_lock locking rules are per-address-family, 178 * so split the lock classes by using a per-AF key: 179 */ 180static struct lock_class_key af_callback_keys[AF_MAX]; 181 182/* Take into consideration the size of the struct sk_buff overhead in the 183 * determination of these values, since that is non-constant across 184 * platforms. This makes socket queueing behavior and performance 185 * not depend upon such differences. 186 */ 187#define _SK_MEM_PACKETS 256 188#define _SK_MEM_OVERHEAD (sizeof(struct sk_buff) + 256) 189#define SK_WMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS) 190#define SK_RMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS) 191 192/* Run time adjustable parameters. */ 193__u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX; 194__u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX; 195__u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX; 196__u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX; 197 198/* Maximal space eaten by iovec or ancilliary data plus some space */ 199int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512); 200 201static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen) 202{ 203 struct timeval tv; 204 205 if (optlen < sizeof(tv)) 206 return -EINVAL; 207 if (copy_from_user(&tv, optval, sizeof(tv))) 208 return -EFAULT; 209 210 *timeo_p = MAX_SCHEDULE_TIMEOUT; 211 if (tv.tv_sec == 0 && tv.tv_usec == 0) 212 return 0; 213 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1)) 214 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ); 215 return 0; 216} 217 218static void sock_warn_obsolete_bsdism(const char *name) 219{ 220 static int warned; 221 static char warncomm[TASK_COMM_LEN]; 222 if (strcmp(warncomm, current->comm) && warned < 5) { 223 strcpy(warncomm, current->comm); 224 printk(KERN_WARNING "process `%s' is using obsolete " 225 "%s SO_BSDCOMPAT\n", warncomm, name); 226 warned++; 227 } 228} 229 230static void sock_disable_timestamp(struct sock *sk) 231{ 232 if (sock_flag(sk, SOCK_TIMESTAMP)) { 233 sock_reset_flag(sk, SOCK_TIMESTAMP); 234 net_disable_timestamp(); 235 } 236} 237 238 239int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) 240{ 241 int err = 0; 242 int skb_len; 243 244 /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces 245 number of warnings when compiling with -W --ANK 246 */ 247 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >= 248 (unsigned)sk->sk_rcvbuf) { 249 err = -ENOMEM; 250 goto out; 251 } 252 253 err = sk_filter(sk, skb); 254 if (err) 255 goto out; 256 257 skb->dev = NULL; 258 skb_set_owner_r(skb, sk); 259 260 /* Cache the SKB length before we tack it onto the receive 261 * queue. Once it is added it no longer belongs to us and 262 * may be freed by other threads of control pulling packets 263 * from the queue. 264 */ 265 skb_len = skb->len; 266 267 skb_queue_tail(&sk->sk_receive_queue, skb); 268 269 if (!sock_flag(sk, SOCK_DEAD)) 270 sk->sk_data_ready(sk, skb_len); 271out: 272 return err; 273} 274EXPORT_SYMBOL(sock_queue_rcv_skb); 275 276int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested) 277{ 278 int rc = NET_RX_SUCCESS; 279 280 if (sk_filter(sk, skb)) 281 goto discard_and_relse; 282 283 skb->dev = NULL; 284 285 if (nested) 286 bh_lock_sock_nested(sk); 287 else 288 bh_lock_sock(sk); 289 if (!sock_owned_by_user(sk)) { 290 /* 291 * trylock + unlock semantics: 292 */ 293 mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_); 294 295 rc = sk->sk_backlog_rcv(sk, skb); 296 297 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_); 298 } else 299 sk_add_backlog(sk, skb); 300 bh_unlock_sock(sk); 301out: 302 sock_put(sk); 303 return rc; 304discard_and_relse: 305 kfree_skb(skb); 306 goto out; 307} 308EXPORT_SYMBOL(sk_receive_skb); 309 310struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie) 311{ 312 struct dst_entry *dst = sk->sk_dst_cache; 313 314 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) { 315 sk->sk_dst_cache = NULL; 316 dst_release(dst); 317 return NULL; 318 } 319 320 return dst; 321} 322EXPORT_SYMBOL(__sk_dst_check); 323 324struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie) 325{ 326 struct dst_entry *dst = sk_dst_get(sk); 327 328 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) { 329 sk_dst_reset(sk); 330 dst_release(dst); 331 return NULL; 332 } 333 334 return dst; 335} 336EXPORT_SYMBOL(sk_dst_check); 337 338/* 339 * This is meant for all protocols to use and covers goings on 340 * at the socket level. Everything here is generic. 341 */ 342 343int sock_setsockopt(struct socket *sock, int level, int optname, 344 char __user *optval, int optlen) 345{ 346 struct sock *sk=sock->sk; 347 struct sk_filter *filter; 348 int val; 349 int valbool; 350 struct linger ling; 351 int ret = 0; 352 353 /* 354 * Options without arguments 355 */ 356 357#ifdef SO_DONTLINGER /* Compatibility item... */ 358 if (optname == SO_DONTLINGER) { 359 lock_sock(sk); 360 sock_reset_flag(sk, SOCK_LINGER); 361 release_sock(sk); 362 return 0; 363 } 364#endif 365 366 if (optlen < sizeof(int)) 367 return -EINVAL; 368 369 if (get_user(val, (int __user *)optval)) 370 return -EFAULT; 371 372 valbool = val?1:0; 373 374 lock_sock(sk); 375 376 switch(optname) { 377 case SO_DEBUG: 378 if (val && !capable(CAP_NET_ADMIN)) { 379 ret = -EACCES; 380 } 381 else if (valbool) 382 sock_set_flag(sk, SOCK_DBG); 383 else 384 sock_reset_flag(sk, SOCK_DBG); 385 break; 386 case SO_REUSEADDR: 387 sk->sk_reuse = valbool; 388 break; 389 case SO_TYPE: 390 case SO_ERROR: 391 ret = -ENOPROTOOPT; 392 break; 393 case SO_DONTROUTE: 394 if (valbool) 395 sock_set_flag(sk, SOCK_LOCALROUTE); 396 else 397 sock_reset_flag(sk, SOCK_LOCALROUTE); 398 break; 399 case SO_BROADCAST: 400 sock_valbool_flag(sk, SOCK_BROADCAST, valbool); 401 break; 402 case SO_SNDBUF: 403 /* Don't error on this BSD doesn't and if you think 404 about it this is right. Otherwise apps have to 405 play 'guess the biggest size' games. RCVBUF/SNDBUF 406 are treated in BSD as hints */ 407 408 if (val > sysctl_wmem_max) 409 val = sysctl_wmem_max; 410set_sndbuf: 411 sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 412 if ((val * 2) < SOCK_MIN_SNDBUF) 413 sk->sk_sndbuf = SOCK_MIN_SNDBUF; 414 else 415 sk->sk_sndbuf = val * 2; 416 417 /* 418 * Wake up sending tasks if we 419 * upped the value. 420 */ 421 sk->sk_write_space(sk); 422 break; 423 424 case SO_SNDBUFFORCE: 425 if (!capable(CAP_NET_ADMIN)) { 426 ret = -EPERM; 427 break; 428 } 429 goto set_sndbuf; 430 431 case SO_RCVBUF: 432 /* Don't error on this BSD doesn't and if you think 433 about it this is right. Otherwise apps have to 434 play 'guess the biggest size' games. RCVBUF/SNDBUF 435 are treated in BSD as hints */ 436 437 if (val > sysctl_rmem_max) 438 val = sysctl_rmem_max; 439set_rcvbuf: 440 sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 441 /* 442 * We double it on the way in to account for 443 * "struct sk_buff" etc. overhead. Applications 444 * assume that the SO_RCVBUF setting they make will 445 * allow that much actual data to be received on that 446 * socket. 447 * 448 * Applications are unaware that "struct sk_buff" and 449 * other overheads allocate from the receive buffer 450 * during socket buffer allocation. 451 * 452 * And after considering the possible alternatives, 453 * returning the value we actually used in getsockopt 454 * is the most desirable behavior. 455 */ 456 if ((val * 2) < SOCK_MIN_RCVBUF) 457 sk->sk_rcvbuf = SOCK_MIN_RCVBUF; 458 else 459 sk->sk_rcvbuf = val * 2; 460 break; 461 462 case SO_RCVBUFFORCE: 463 if (!capable(CAP_NET_ADMIN)) { 464 ret = -EPERM; 465 break; 466 } 467 goto set_rcvbuf; 468 469 case SO_KEEPALIVE: 470#ifdef CONFIG_INET 471 if (sk->sk_protocol == IPPROTO_TCP) 472 tcp_set_keepalive(sk, valbool); 473#endif 474 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool); 475 break; 476 477 case SO_OOBINLINE: 478 sock_valbool_flag(sk, SOCK_URGINLINE, valbool); 479 break; 480 481 case SO_NO_CHECK: 482 sk->sk_no_check = valbool; 483 break; 484 485 case SO_PRIORITY: 486 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN)) 487 sk->sk_priority = val; 488 else 489 ret = -EPERM; 490 break; 491 492 case SO_LINGER: 493 if (optlen < sizeof(ling)) { 494 ret = -EINVAL; /* 1003.1g */ 495 break; 496 } 497 if (copy_from_user(&ling,optval,sizeof(ling))) { 498 ret = -EFAULT; 499 break; 500 } 501 if (!ling.l_onoff) 502 sock_reset_flag(sk, SOCK_LINGER); 503 else { 504#if (BITS_PER_LONG == 32) 505 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ) 506 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT; 507 else 508#endif 509 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ; 510 sock_set_flag(sk, SOCK_LINGER); 511 } 512 break; 513 514 case SO_BSDCOMPAT: 515 sock_warn_obsolete_bsdism("setsockopt"); 516 break; 517 518 case SO_PASSCRED: 519 if (valbool) 520 set_bit(SOCK_PASSCRED, &sock->flags); 521 else 522 clear_bit(SOCK_PASSCRED, &sock->flags); 523 break; 524 525 case SO_TIMESTAMP: 526 case SO_TIMESTAMPNS: 527 if (valbool) { 528 if (optname == SO_TIMESTAMP) 529 sock_reset_flag(sk, SOCK_RCVTSTAMPNS); 530 else 531 sock_set_flag(sk, SOCK_RCVTSTAMPNS); 532 sock_set_flag(sk, SOCK_RCVTSTAMP); 533 sock_enable_timestamp(sk); 534 } else { 535 sock_reset_flag(sk, SOCK_RCVTSTAMP); 536 sock_reset_flag(sk, SOCK_RCVTSTAMPNS); 537 } 538 break; 539 540 case SO_RCVLOWAT: 541 if (val < 0) 542 val = INT_MAX; 543 sk->sk_rcvlowat = val ? : 1; 544 break; 545 546 case SO_RCVTIMEO: 547 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen); 548 break; 549 550 case SO_SNDTIMEO: 551 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen); 552 break; 553 554#ifdef CONFIG_NETDEVICES 555 case SO_BINDTODEVICE: 556 { 557 char devname[IFNAMSIZ]; 558 559 /* Sorry... */ 560 if (!capable(CAP_NET_RAW)) { 561 ret = -EPERM; 562 break; 563 } 564 565 /* Bind this socket to a particular device like "eth0", 566 * as specified in the passed interface name. If the 567 * name is "" or the option length is zero the socket 568 * is not bound. 569 */ 570 571 if (!valbool) { 572 sk->sk_bound_dev_if = 0; 573 } else { 574 if (optlen > IFNAMSIZ - 1) 575 optlen = IFNAMSIZ - 1; 576 memset(devname, 0, sizeof(devname)); 577 if (copy_from_user(devname, optval, optlen)) { 578 ret = -EFAULT; 579 break; 580 } 581 582 /* Remove any cached route for this socket. */ 583 sk_dst_reset(sk); 584 585 if (devname[0] == '\0') { 586 sk->sk_bound_dev_if = 0; 587 } else { 588 struct net_device *dev = dev_get_by_name(devname); 589 if (!dev) { 590 ret = -ENODEV; 591 break; 592 } 593 sk->sk_bound_dev_if = dev->ifindex; 594 dev_put(dev); 595 } 596 } 597 break; 598 } 599#endif 600 601 602 case SO_ATTACH_FILTER: 603 ret = -EINVAL; 604 if (optlen == sizeof(struct sock_fprog)) { 605 struct sock_fprog fprog; 606 607 ret = -EFAULT; 608 if (copy_from_user(&fprog, optval, sizeof(fprog))) 609 break; 610 611 ret = sk_attach_filter(&fprog, sk); 612 } 613 break; 614 615 case SO_DETACH_FILTER: 616 rcu_read_lock_bh(); 617 filter = rcu_dereference(sk->sk_filter); 618 if (filter) { 619 rcu_assign_pointer(sk->sk_filter, NULL); 620 sk_filter_release(sk, filter); 621 rcu_read_unlock_bh(); 622 break; 623 } 624 rcu_read_unlock_bh(); 625 ret = -ENONET; 626 break; 627 628 case SO_PASSSEC: 629 if (valbool) 630 set_bit(SOCK_PASSSEC, &sock->flags); 631 else 632 clear_bit(SOCK_PASSSEC, &sock->flags); 633 break; 634 635 /* We implement the SO_SNDLOWAT etc to 636 not be settable (1003.1g 5.3) */ 637 default: 638 ret = -ENOPROTOOPT; 639 break; 640 } 641 release_sock(sk); 642 return ret; 643} 644 645 646int sock_getsockopt(struct socket *sock, int level, int optname, 647 char __user *optval, int __user *optlen) 648{ 649 struct sock *sk = sock->sk; 650 651 union { 652 int val; 653 struct linger ling; 654 struct timeval tm; 655 } v; 656 657 unsigned int lv = sizeof(int); 658 int len; 659 660 if (get_user(len, optlen)) 661 return -EFAULT; 662 if (len < 0) 663 return -EINVAL; 664 665 switch(optname) { 666 case SO_DEBUG: 667 v.val = sock_flag(sk, SOCK_DBG); 668 break; 669 670 case SO_DONTROUTE: 671 v.val = sock_flag(sk, SOCK_LOCALROUTE); 672 break; 673 674 case SO_BROADCAST: 675 v.val = !!sock_flag(sk, SOCK_BROADCAST); 676 break; 677 678 case SO_SNDBUF: 679 v.val = sk->sk_sndbuf; 680 break; 681 682 case SO_RCVBUF: 683 v.val = sk->sk_rcvbuf; 684 break; 685 686 case SO_REUSEADDR: 687 v.val = sk->sk_reuse; 688 break; 689 690 case SO_KEEPALIVE: 691 v.val = !!sock_flag(sk, SOCK_KEEPOPEN); 692 break; 693 694 case SO_TYPE: 695 v.val = sk->sk_type; 696 break; 697 698 case SO_ERROR: 699 v.val = -sock_error(sk); 700 if (v.val==0) 701 v.val = xchg(&sk->sk_err_soft, 0); 702 break; 703 704 case SO_OOBINLINE: 705 v.val = !!sock_flag(sk, SOCK_URGINLINE); 706 break; 707 708 case SO_NO_CHECK: 709 v.val = sk->sk_no_check; 710 break; 711 712 case SO_PRIORITY: 713 v.val = sk->sk_priority; 714 break; 715 716 case SO_LINGER: 717 lv = sizeof(v.ling); 718 v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER); 719 v.ling.l_linger = sk->sk_lingertime / HZ; 720 break; 721 722 case SO_BSDCOMPAT: 723 sock_warn_obsolete_bsdism("getsockopt"); 724 break; 725 726 case SO_TIMESTAMP: 727 v.val = sock_flag(sk, SOCK_RCVTSTAMP) && 728 !sock_flag(sk, SOCK_RCVTSTAMPNS); 729 break; 730 731 case SO_TIMESTAMPNS: 732 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS); 733 break; 734 735 case SO_RCVTIMEO: 736 lv=sizeof(struct timeval); 737 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) { 738 v.tm.tv_sec = 0; 739 v.tm.tv_usec = 0; 740 } else { 741 v.tm.tv_sec = sk->sk_rcvtimeo / HZ; 742 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ; 743 } 744 break; 745 746 case SO_SNDTIMEO: 747 lv=sizeof(struct timeval); 748 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) { 749 v.tm.tv_sec = 0; 750 v.tm.tv_usec = 0; 751 } else { 752 v.tm.tv_sec = sk->sk_sndtimeo / HZ; 753 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ; 754 } 755 break; 756 757 case SO_RCVLOWAT: 758 v.val = sk->sk_rcvlowat; 759 break; 760 761 case SO_SNDLOWAT: 762 v.val=1; 763 break; 764 765 case SO_PASSCRED: 766 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0; 767 break; 768 769 case SO_PEERCRED: 770 if (len > sizeof(sk->sk_peercred)) 771 len = sizeof(sk->sk_peercred); 772 if (copy_to_user(optval, &sk->sk_peercred, len)) 773 return -EFAULT; 774 goto lenout; 775 776 case SO_PEERNAME: 777 { 778 char address[128]; 779 780 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2)) 781 return -ENOTCONN; 782 if (lv < len) 783 return -EINVAL; 784 if (copy_to_user(optval, address, len)) 785 return -EFAULT; 786 goto lenout; 787 } 788 789 /* Dubious BSD thing... Probably nobody even uses it, but 790 * the UNIX standard wants it for whatever reason... -DaveM 791 */ 792 case SO_ACCEPTCONN: 793 v.val = sk->sk_state == TCP_LISTEN; 794 break; 795 796 case SO_PASSSEC: 797 v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0; 798 break; 799 800 case SO_PEERSEC: 801 return security_socket_getpeersec_stream(sock, optval, optlen, len); 802 803 default: 804 return -ENOPROTOOPT; 805 } 806 807 if (len > lv) 808 len = lv; 809 if (copy_to_user(optval, &v, len)) 810 return -EFAULT; 811lenout: 812 if (put_user(len, optlen)) 813 return -EFAULT; 814 return 0; 815} 816 817/* 818 * Initialize an sk_lock. 819 * 820 * (We also register the sk_lock with the lock validator.) 821 */ 822static inline void sock_lock_init(struct sock *sk) 823{ 824 sock_lock_init_class_and_name(sk, 825 af_family_slock_key_strings[sk->sk_family], 826 af_family_slock_keys + sk->sk_family, 827 af_family_key_strings[sk->sk_family], 828 af_family_keys + sk->sk_family); 829} 830 831/** 832 * sk_alloc - All socket objects are allocated here 833 * @family: protocol family 834 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc) 835 * @prot: struct proto associated with this new sock instance 836 * @zero_it: if we should zero the newly allocated sock 837 */ 838struct sock *sk_alloc(int family, gfp_t priority, 839 struct proto *prot, int zero_it) 840{ 841 struct sock *sk = NULL; 842 struct kmem_cache *slab = prot->slab; 843 844 if (slab != NULL) 845 sk = kmem_cache_alloc(slab, priority); 846 else 847 sk = kmalloc(prot->obj_size, priority); 848 849 if (sk) { 850 if (zero_it) { 851 memset(sk, 0, prot->obj_size); 852 sk->sk_family = family; 853 /* 854 * See comment in struct sock definition to understand 855 * why we need sk_prot_creator -acme 856 */ 857 sk->sk_prot = sk->sk_prot_creator = prot; 858 sock_lock_init(sk); 859 } 860 861 if (security_sk_alloc(sk, family, priority)) 862 goto out_free; 863 864 if (!try_module_get(prot->owner)) 865 goto out_free; 866 } 867 return sk; 868 869out_free: 870 if (slab != NULL) 871 kmem_cache_free(slab, sk); 872 else 873 kfree(sk); 874 return NULL; 875} 876 877void sk_free(struct sock *sk) 878{ 879 struct sk_filter *filter; 880 struct module *owner = sk->sk_prot_creator->owner; 881 882 if (sk->sk_destruct) 883 sk->sk_destruct(sk); 884 885 filter = rcu_dereference(sk->sk_filter); 886 if (filter) { 887 sk_filter_release(sk, filter); 888 rcu_assign_pointer(sk->sk_filter, NULL); 889 } 890 891 sock_disable_timestamp(sk); 892 893 if (atomic_read(&sk->sk_omem_alloc)) 894 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n", 895 __FUNCTION__, atomic_read(&sk->sk_omem_alloc)); 896 897 security_sk_free(sk); 898 if (sk->sk_prot_creator->slab != NULL) 899 kmem_cache_free(sk->sk_prot_creator->slab, sk); 900 else 901 kfree(sk); 902 module_put(owner); 903} 904 905struct sock *sk_clone(const struct sock *sk, const gfp_t priority) 906{ 907 struct sock *newsk = sk_alloc(sk->sk_family, priority, sk->sk_prot, 0); 908 909 if (newsk != NULL) { 910 struct sk_filter *filter; 911 912 sock_copy(newsk, sk); 913 914 /* SANITY */ 915 sk_node_init(&newsk->sk_node); 916 sock_lock_init(newsk); 917 bh_lock_sock(newsk); 918 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL; 919 920 atomic_set(&newsk->sk_rmem_alloc, 0); 921 atomic_set(&newsk->sk_wmem_alloc, 0); 922 atomic_set(&newsk->sk_omem_alloc, 0); 923 skb_queue_head_init(&newsk->sk_receive_queue); 924 skb_queue_head_init(&newsk->sk_write_queue); 925#ifdef CONFIG_NET_DMA 926 skb_queue_head_init(&newsk->sk_async_wait_queue); 927#endif 928 929 rwlock_init(&newsk->sk_dst_lock); 930 rwlock_init(&newsk->sk_callback_lock); 931 lockdep_set_class(&newsk->sk_callback_lock, 932 af_callback_keys + newsk->sk_family); 933 934 newsk->sk_dst_cache = NULL; 935 newsk->sk_wmem_queued = 0; 936 newsk->sk_forward_alloc = 0; 937 newsk->sk_send_head = NULL; 938 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK; 939 940 sock_reset_flag(newsk, SOCK_DONE); 941 skb_queue_head_init(&newsk->sk_error_queue); 942 943 filter = newsk->sk_filter; 944 if (filter != NULL) 945 sk_filter_charge(newsk, filter); 946 947 if (unlikely(xfrm_sk_clone_policy(newsk))) { 948 /* It is still raw copy of parent, so invalidate 949 * destructor and make plain sk_free() */ 950 newsk->sk_destruct = NULL; 951 sk_free(newsk); 952 newsk = NULL; 953 goto out; 954 } 955 956 newsk->sk_err = 0; 957 newsk->sk_priority = 0; 958 atomic_set(&newsk->sk_refcnt, 2); 959 960 /* 961 * Increment the counter in the same struct proto as the master 962 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that 963 * is the same as sk->sk_prot->socks, as this field was copied 964 * with memcpy). 965 * 966 * This _changes_ the previous behaviour, where 967 * tcp_create_openreq_child always was incrementing the 968 * equivalent to tcp_prot->socks (inet_sock_nr), so this have 969 * to be taken into account in all callers. -acme 970 */ 971 sk_refcnt_debug_inc(newsk); 972 newsk->sk_socket = NULL; 973 newsk->sk_sleep = NULL; 974 975 if (newsk->sk_prot->sockets_allocated) 976 atomic_inc(newsk->sk_prot->sockets_allocated); 977 } 978out: 979 return newsk; 980} 981 982EXPORT_SYMBOL_GPL(sk_clone); 983 984void sk_setup_caps(struct sock *sk, struct dst_entry *dst) 985{ 986 __sk_dst_set(sk, dst); 987 sk->sk_route_caps = dst->dev->features; 988 if (sk->sk_route_caps & NETIF_F_GSO) 989 sk->sk_route_caps |= NETIF_F_GSO_MASK; 990 if (sk_can_gso(sk)) { 991 if (dst->header_len) 992 sk->sk_route_caps &= ~NETIF_F_GSO_MASK; 993 else 994 sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM; 995 } 996} 997EXPORT_SYMBOL_GPL(sk_setup_caps); 998 999void __init sk_init(void) 1000{ 1001 if (num_physpages <= 4096) { 1002 sysctl_wmem_max = 32767; 1003 sysctl_rmem_max = 32767; 1004 sysctl_wmem_default = 32767; 1005 sysctl_rmem_default = 32767; 1006 } else if (num_physpages >= 131072) { 1007 sysctl_wmem_max = 131071; 1008 sysctl_rmem_max = 131071; 1009 } 1010} 1011 1012/* 1013 * Simple resource managers for sockets. 1014 */ 1015 1016 1017/* 1018 * Write buffer destructor automatically called from kfree_skb. 1019 */ 1020void sock_wfree(struct sk_buff *skb) 1021{ 1022 struct sock *sk = skb->sk; 1023 1024 /* In case it might be waiting for more memory. */ 1025 atomic_sub(skb->truesize, &sk->sk_wmem_alloc); 1026 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) 1027 sk->sk_write_space(sk); 1028 sock_put(sk); 1029} 1030 1031/* 1032 * Read buffer destructor automatically called from kfree_skb. 1033 */ 1034void sock_rfree(struct sk_buff *skb) 1035{ 1036 struct sock *sk = skb->sk; 1037 1038 atomic_sub(skb->truesize, &sk->sk_rmem_alloc); 1039} 1040 1041 1042int sock_i_uid(struct sock *sk) 1043{ 1044 int uid; 1045 1046 read_lock(&sk->sk_callback_lock); 1047 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0; 1048 read_unlock(&sk->sk_callback_lock); 1049 return uid; 1050} 1051 1052unsigned long sock_i_ino(struct sock *sk) 1053{ 1054 unsigned long ino; 1055 1056 read_lock(&sk->sk_callback_lock); 1057 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0; 1058 read_unlock(&sk->sk_callback_lock); 1059 return ino; 1060} 1061 1062/* 1063 * Allocate a skb from the socket's send buffer. 1064 */ 1065struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, 1066 gfp_t priority) 1067{ 1068 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) { 1069 struct sk_buff * skb = alloc_skb(size, priority); 1070 if (skb) { 1071 skb_set_owner_w(skb, sk); 1072 return skb; 1073 } 1074 } 1075 return NULL; 1076} 1077 1078/* 1079 * Allocate a skb from the socket's receive buffer. 1080 */ 1081struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, 1082 gfp_t priority) 1083{ 1084 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) { 1085 struct sk_buff *skb = alloc_skb(size, priority); 1086 if (skb) { 1087 skb_set_owner_r(skb, sk); 1088 return skb; 1089 } 1090 } 1091 return NULL; 1092} 1093 1094/* 1095 * Allocate a memory block from the socket's option memory buffer. 1096 */ 1097void *sock_kmalloc(struct sock *sk, int size, gfp_t priority) 1098{ 1099 if ((unsigned)size <= sysctl_optmem_max && 1100 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) { 1101 void *mem; 1102 /* First do the add, to avoid the race if kmalloc 1103 * might sleep. 1104 */ 1105 atomic_add(size, &sk->sk_omem_alloc); 1106 mem = kmalloc(size, priority); 1107 if (mem) 1108 return mem; 1109 atomic_sub(size, &sk->sk_omem_alloc); 1110 } 1111 return NULL; 1112} 1113 1114/* 1115 * Free an option memory block. 1116 */ 1117void sock_kfree_s(struct sock *sk, void *mem, int size) 1118{ 1119 kfree(mem); 1120 atomic_sub(size, &sk->sk_omem_alloc); 1121} 1122 1123/* It is almost wait_for_tcp_memory minus release_sock/lock_sock. 1124 I think, these locks should be removed for datagram sockets. 1125 */ 1126static long sock_wait_for_wmem(struct sock * sk, long timeo) 1127{ 1128 DEFINE_WAIT(wait); 1129 1130 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 1131 for (;;) { 1132 if (!timeo) 1133 break; 1134 if (signal_pending(current)) 1135 break; 1136 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); 1137 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 1138 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) 1139 break; 1140 if (sk->sk_shutdown & SEND_SHUTDOWN) 1141 break; 1142 if (sk->sk_err) 1143 break; 1144 timeo = schedule_timeout(timeo); 1145 } 1146 finish_wait(sk->sk_sleep, &wait); 1147 return timeo; 1148} 1149 1150 1151/* 1152 * Generic send/receive buffer handlers 1153 */ 1154 1155static struct sk_buff *sock_alloc_send_pskb(struct sock *sk, 1156 unsigned long header_len, 1157 unsigned long data_len, 1158 int noblock, int *errcode) 1159{ 1160 struct sk_buff *skb; 1161 gfp_t gfp_mask; 1162 long timeo; 1163 int err; 1164 1165 gfp_mask = sk->sk_allocation; 1166 if (gfp_mask & __GFP_WAIT) 1167 gfp_mask |= __GFP_REPEAT; 1168 1169 timeo = sock_sndtimeo(sk, noblock); 1170 while (1) { 1171 err = sock_error(sk); 1172 if (err != 0) 1173 goto failure; 1174 1175 err = -EPIPE; 1176 if (sk->sk_shutdown & SEND_SHUTDOWN) 1177 goto failure; 1178 1179 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) { 1180 skb = alloc_skb(header_len, gfp_mask); 1181 if (skb) { 1182 int npages; 1183 int i; 1184 1185 /* No pages, we're done... */ 1186 if (!data_len) 1187 break; 1188 1189 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT; 1190 skb->truesize += data_len; 1191 skb_shinfo(skb)->nr_frags = npages; 1192 for (i = 0; i < npages; i++) { 1193 struct page *page; 1194 skb_frag_t *frag; 1195 1196 page = alloc_pages(sk->sk_allocation, 0); 1197 if (!page) { 1198 err = -ENOBUFS; 1199 skb_shinfo(skb)->nr_frags = i; 1200 kfree_skb(skb); 1201 goto failure; 1202 } 1203 1204 frag = &skb_shinfo(skb)->frags[i]; 1205 frag->page = page; 1206 frag->page_offset = 0; 1207 frag->size = (data_len >= PAGE_SIZE ? 1208 PAGE_SIZE : 1209 data_len); 1210 data_len -= PAGE_SIZE; 1211 } 1212 1213 /* Full success... */ 1214 break; 1215 } 1216 err = -ENOBUFS; 1217 goto failure; 1218 } 1219 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags); 1220 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); 1221 err = -EAGAIN; 1222 if (!timeo) 1223 goto failure; 1224 if (signal_pending(current)) 1225 goto interrupted; 1226 timeo = sock_wait_for_wmem(sk, timeo); 1227 } 1228 1229 skb_set_owner_w(skb, sk); 1230 return skb; 1231 1232interrupted: 1233 err = sock_intr_errno(timeo); 1234failure: 1235 *errcode = err; 1236 return NULL; 1237} 1238 1239struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, 1240 int noblock, int *errcode) 1241{ 1242 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode); 1243} 1244 1245static void __lock_sock(struct sock *sk) 1246{ 1247 DEFINE_WAIT(wait); 1248 1249 for (;;) { 1250 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait, 1251 TASK_UNINTERRUPTIBLE); 1252 spin_unlock_bh(&sk->sk_lock.slock); 1253 schedule(); 1254 spin_lock_bh(&sk->sk_lock.slock); 1255 if (!sock_owned_by_user(sk)) 1256 break; 1257 } 1258 finish_wait(&sk->sk_lock.wq, &wait); 1259} 1260 1261static void __release_sock(struct sock *sk) 1262{ 1263 struct sk_buff *skb = sk->sk_backlog.head; 1264 1265 do { 1266 sk->sk_backlog.head = sk->sk_backlog.tail = NULL; 1267 bh_unlock_sock(sk); 1268 1269 do { 1270 struct sk_buff *next = skb->next; 1271 1272 skb->next = NULL; 1273 sk->sk_backlog_rcv(sk, skb); 1274 1275 /* 1276 * We are in process context here with softirqs 1277 * disabled, use cond_resched_softirq() to preempt. 1278 * This is safe to do because we've taken the backlog 1279 * queue private: 1280 */ 1281 cond_resched_softirq(); 1282 1283 skb = next; 1284 } while (skb != NULL); 1285 1286 bh_lock_sock(sk); 1287 } while ((skb = sk->sk_backlog.head) != NULL); 1288} 1289 1290/** 1291 * sk_wait_data - wait for data to arrive at sk_receive_queue 1292 * @sk: sock to wait on 1293 * @timeo: for how long 1294 * 1295 * Now socket state including sk->sk_err is changed only under lock, 1296 * hence we may omit checks after joining wait queue. 1297 * We check receive queue before schedule() only as optimization; 1298 * it is very likely that release_sock() added new data. 1299 */ 1300int sk_wait_data(struct sock *sk, long *timeo) 1301{ 1302 int rc; 1303 DEFINE_WAIT(wait); 1304 1305 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 1306 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 1307 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue)); 1308 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 1309 finish_wait(sk->sk_sleep, &wait); 1310 return rc; 1311} 1312 1313EXPORT_SYMBOL(sk_wait_data); 1314 1315/* 1316 * Set of default routines for initialising struct proto_ops when 1317 * the protocol does not support a particular function. In certain 1318 * cases where it makes no sense for a protocol to have a "do nothing" 1319 * function, some default processing is provided. 1320 */ 1321 1322int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len) 1323{ 1324 return -EOPNOTSUPP; 1325} 1326 1327int sock_no_connect(struct socket *sock, struct sockaddr *saddr, 1328 int len, int flags) 1329{ 1330 return -EOPNOTSUPP; 1331} 1332 1333int sock_no_socketpair(struct socket *sock1, struct socket *sock2) 1334{ 1335 return -EOPNOTSUPP; 1336} 1337 1338int sock_no_accept(struct socket *sock, struct socket *newsock, int flags) 1339{ 1340 return -EOPNOTSUPP; 1341} 1342 1343int sock_no_getname(struct socket *sock, struct sockaddr *saddr, 1344 int *len, int peer) 1345{ 1346 return -EOPNOTSUPP; 1347} 1348 1349unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt) 1350{ 1351 return 0; 1352} 1353 1354int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1355{ 1356 return -EOPNOTSUPP; 1357} 1358 1359int sock_no_listen(struct socket *sock, int backlog) 1360{ 1361 return -EOPNOTSUPP; 1362} 1363 1364int sock_no_shutdown(struct socket *sock, int how) 1365{ 1366 return -EOPNOTSUPP; 1367} 1368 1369int sock_no_setsockopt(struct socket *sock, int level, int optname, 1370 char __user *optval, int optlen) 1371{ 1372 return -EOPNOTSUPP; 1373} 1374 1375int sock_no_getsockopt(struct socket *sock, int level, int optname, 1376 char __user *optval, int __user *optlen) 1377{ 1378 return -EOPNOTSUPP; 1379} 1380 1381int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m, 1382 size_t len) 1383{ 1384 return -EOPNOTSUPP; 1385} 1386 1387int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m, 1388 size_t len, int flags) 1389{ 1390 return -EOPNOTSUPP; 1391} 1392 1393int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma) 1394{ 1395 /* Mirror missing mmap method error code */ 1396 return -ENODEV; 1397} 1398 1399ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags) 1400{ 1401 ssize_t res; 1402 struct msghdr msg = {.msg_flags = flags}; 1403 struct kvec iov; 1404 char *kaddr = kmap(page); 1405 iov.iov_base = kaddr + offset; 1406 iov.iov_len = size; 1407 res = kernel_sendmsg(sock, &msg, &iov, 1, size); 1408 kunmap(page); 1409 return res; 1410} 1411 1412/* 1413 * Default Socket Callbacks 1414 */ 1415 1416static void sock_def_wakeup(struct sock *sk) 1417{ 1418 read_lock(&sk->sk_callback_lock); 1419 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1420 wake_up_interruptible_all(sk->sk_sleep); 1421 read_unlock(&sk->sk_callback_lock); 1422} 1423 1424static void sock_def_error_report(struct sock *sk) 1425{ 1426 read_lock(&sk->sk_callback_lock); 1427 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1428 wake_up_interruptible(sk->sk_sleep); 1429 sk_wake_async(sk,0,POLL_ERR); 1430 read_unlock(&sk->sk_callback_lock); 1431} 1432 1433static void sock_def_readable(struct sock *sk, int len) 1434{ 1435 read_lock(&sk->sk_callback_lock); 1436 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1437 wake_up_interruptible(sk->sk_sleep); 1438 sk_wake_async(sk,1,POLL_IN); 1439 read_unlock(&sk->sk_callback_lock); 1440} 1441 1442static void sock_def_write_space(struct sock *sk) 1443{ 1444 read_lock(&sk->sk_callback_lock); 1445 1446 /* Do not wake up a writer until he can make "significant" 1447 * progress. --DaveM 1448 */ 1449 if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) { 1450 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) 1451 wake_up_interruptible(sk->sk_sleep); 1452 1453 /* Should agree with poll, otherwise some programs break */ 1454 if (sock_writeable(sk)) 1455 sk_wake_async(sk, 2, POLL_OUT); 1456 } 1457 1458 read_unlock(&sk->sk_callback_lock); 1459} 1460 1461static void sock_def_destruct(struct sock *sk) 1462{ 1463 kfree(sk->sk_protinfo); 1464} 1465 1466void sk_send_sigurg(struct sock *sk) 1467{ 1468 if (sk->sk_socket && sk->sk_socket->file) 1469 if (send_sigurg(&sk->sk_socket->file->f_owner)) 1470 sk_wake_async(sk, 3, POLL_PRI); 1471} 1472 1473void sk_reset_timer(struct sock *sk, struct timer_list* timer, 1474 unsigned long expires) 1475{ 1476 if (!mod_timer(timer, expires)) 1477 sock_hold(sk); 1478} 1479 1480EXPORT_SYMBOL(sk_reset_timer); 1481 1482void sk_stop_timer(struct sock *sk, struct timer_list* timer) 1483{ 1484 if (timer_pending(timer) && del_timer(timer)) 1485 __sock_put(sk); 1486} 1487 1488EXPORT_SYMBOL(sk_stop_timer); 1489 1490void sock_init_data(struct socket *sock, struct sock *sk) 1491{ 1492 skb_queue_head_init(&sk->sk_receive_queue); 1493 skb_queue_head_init(&sk->sk_write_queue); 1494 skb_queue_head_init(&sk->sk_error_queue); 1495#ifdef CONFIG_NET_DMA 1496 skb_queue_head_init(&sk->sk_async_wait_queue); 1497#endif 1498 1499 sk->sk_send_head = NULL; 1500 1501 init_timer(&sk->sk_timer); 1502 1503 sk->sk_allocation = GFP_KERNEL; 1504 sk->sk_rcvbuf = sysctl_rmem_default; 1505 sk->sk_sndbuf = sysctl_wmem_default; 1506 sk->sk_state = TCP_CLOSE; 1507 sk->sk_socket = sock; 1508 1509 sock_set_flag(sk, SOCK_ZAPPED); 1510 1511 if (sock) { 1512 sk->sk_type = sock->type; 1513 sk->sk_sleep = &sock->wait; 1514 sock->sk = sk; 1515 } else 1516 sk->sk_sleep = NULL; 1517 1518 rwlock_init(&sk->sk_dst_lock); 1519 rwlock_init(&sk->sk_callback_lock); 1520 lockdep_set_class(&sk->sk_callback_lock, 1521 af_callback_keys + sk->sk_family); 1522 1523 sk->sk_state_change = sock_def_wakeup; 1524 sk->sk_data_ready = sock_def_readable; 1525 sk->sk_write_space = sock_def_write_space; 1526 sk->sk_error_report = sock_def_error_report; 1527 sk->sk_destruct = sock_def_destruct; 1528 1529 sk->sk_sndmsg_page = NULL; 1530 sk->sk_sndmsg_off = 0; 1531 1532 sk->sk_peercred.pid = 0; 1533 sk->sk_peercred.uid = -1; 1534 sk->sk_peercred.gid = -1; 1535 sk->sk_write_pending = 0; 1536 sk->sk_rcvlowat = 1; 1537 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1538 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT; 1539 1540 sk->sk_stamp = ktime_set(-1L, -1L); 1541 1542 atomic_set(&sk->sk_refcnt, 1); 1543} 1544 1545void fastcall lock_sock_nested(struct sock *sk, int subclass) 1546{ 1547 might_sleep(); 1548 spin_lock_bh(&sk->sk_lock.slock); 1549 if (sk->sk_lock.owner) 1550 __lock_sock(sk); 1551 sk->sk_lock.owner = (void *)1; 1552 spin_unlock(&sk->sk_lock.slock); 1553 /* 1554 * The sk_lock has mutex_lock() semantics here: 1555 */ 1556 mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_); 1557 local_bh_enable(); 1558} 1559 1560EXPORT_SYMBOL(lock_sock_nested); 1561 1562void fastcall release_sock(struct sock *sk) 1563{ 1564 /* 1565 * The sk_lock has mutex_unlock() semantics: 1566 */ 1567 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_); 1568 1569 spin_lock_bh(&sk->sk_lock.slock); 1570 if (sk->sk_backlog.tail) 1571 __release_sock(sk); 1572 sk->sk_lock.owner = NULL; 1573 if (waitqueue_active(&sk->sk_lock.wq)) 1574 wake_up(&sk->sk_lock.wq); 1575 spin_unlock_bh(&sk->sk_lock.slock); 1576} 1577EXPORT_SYMBOL(release_sock); 1578 1579int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp) 1580{ 1581 struct timeval tv; 1582 if (!sock_flag(sk, SOCK_TIMESTAMP)) 1583 sock_enable_timestamp(sk); 1584 tv = ktime_to_timeval(sk->sk_stamp); 1585 if (tv.tv_sec == -1) 1586 return -ENOENT; 1587 if (tv.tv_sec == 0) { 1588 sk->sk_stamp = ktime_get_real(); 1589 tv = ktime_to_timeval(sk->sk_stamp); 1590 } 1591 return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0; 1592} 1593EXPORT_SYMBOL(sock_get_timestamp); 1594 1595int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp) 1596{ 1597 struct timespec ts; 1598 if (!sock_flag(sk, SOCK_TIMESTAMP)) 1599 sock_enable_timestamp(sk); 1600 ts = ktime_to_timespec(sk->sk_stamp); 1601 if (ts.tv_sec == -1) 1602 return -ENOENT; 1603 if (ts.tv_sec == 0) { 1604 sk->sk_stamp = ktime_get_real(); 1605 ts = ktime_to_timespec(sk->sk_stamp); 1606 } 1607 return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0; 1608} 1609EXPORT_SYMBOL(sock_get_timestampns); 1610 1611void sock_enable_timestamp(struct sock *sk) 1612{ 1613 if (!sock_flag(sk, SOCK_TIMESTAMP)) { 1614 sock_set_flag(sk, SOCK_TIMESTAMP); 1615 net_enable_timestamp(); 1616 } 1617} 1618EXPORT_SYMBOL(sock_enable_timestamp); 1619 1620/* 1621 * Get a socket option on an socket. 1622 * 1623 * FIX: POSIX 1003.1g is very ambiguous here. It states that 1624 * asynchronous errors should be reported by getsockopt. We assume 1625 * this means if you specify SO_ERROR (otherwise whats the point of it). 1626 */ 1627int sock_common_getsockopt(struct socket *sock, int level, int optname, 1628 char __user *optval, int __user *optlen) 1629{ 1630 struct sock *sk = sock->sk; 1631 1632 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen); 1633} 1634 1635EXPORT_SYMBOL(sock_common_getsockopt); 1636 1637#ifdef CONFIG_COMPAT 1638int compat_sock_common_getsockopt(struct socket *sock, int level, int optname, 1639 char __user *optval, int __user *optlen) 1640{ 1641 struct sock *sk = sock->sk; 1642 1643 if (sk->sk_prot->compat_getsockopt != NULL) 1644 return sk->sk_prot->compat_getsockopt(sk, level, optname, 1645 optval, optlen); 1646 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen); 1647} 1648EXPORT_SYMBOL(compat_sock_common_getsockopt); 1649#endif 1650 1651int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock, 1652 struct msghdr *msg, size_t size, int flags) 1653{ 1654 struct sock *sk = sock->sk; 1655 int addr_len = 0; 1656 int err; 1657 1658 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT, 1659 flags & ~MSG_DONTWAIT, &addr_len); 1660 if (err >= 0) 1661 msg->msg_namelen = addr_len; 1662 return err; 1663} 1664 1665EXPORT_SYMBOL(sock_common_recvmsg); 1666 1667/* 1668 * Set socket options on an inet socket. 1669 */ 1670int sock_common_setsockopt(struct socket *sock, int level, int optname, 1671 char __user *optval, int optlen) 1672{ 1673 struct sock *sk = sock->sk; 1674 1675 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen); 1676} 1677 1678EXPORT_SYMBOL(sock_common_setsockopt); 1679 1680#ifdef CONFIG_COMPAT 1681int compat_sock_common_setsockopt(struct socket *sock, int level, int optname, 1682 char __user *optval, int optlen) 1683{ 1684 struct sock *sk = sock->sk; 1685 1686 if (sk->sk_prot->compat_setsockopt != NULL) 1687 return sk->sk_prot->compat_setsockopt(sk, level, optname, 1688 optval, optlen); 1689 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen); 1690} 1691EXPORT_SYMBOL(compat_sock_common_setsockopt); 1692#endif 1693 1694void sk_common_release(struct sock *sk) 1695{ 1696 if (sk->sk_prot->destroy) 1697 sk->sk_prot->destroy(sk); 1698 1699 /* 1700 * Observation: when sock_common_release is called, processes have 1701 * no access to socket. But net still has. 1702 * Step one, detach it from networking: 1703 * 1704 * A. Remove from hash tables. 1705 */ 1706 1707 sk->sk_prot->unhash(sk); 1708 1709 /* 1710 * In this point socket cannot receive new packets, but it is possible 1711 * that some packets are in flight because some CPU runs receiver and 1712 * did hash table lookup before we unhashed socket. They will achieve 1713 * receive queue and will be purged by socket destructor. 1714 * 1715 * Also we still have packets pending on receive queue and probably, 1716 * our own packets waiting in device queues. sock_destroy will drain 1717 * receive queue, but transmitted packets will delay socket destruction 1718 * until the last reference will be released. 1719 */ 1720 1721 sock_orphan(sk); 1722 1723 xfrm_sk_free_policy(sk); 1724 1725 sk_refcnt_debug_release(sk); 1726 sock_put(sk); 1727} 1728 1729EXPORT_SYMBOL(sk_common_release); 1730 1731static DEFINE_RWLOCK(proto_list_lock); 1732static LIST_HEAD(proto_list); 1733 1734int proto_register(struct proto *prot, int alloc_slab) 1735{ 1736 char *request_sock_slab_name = NULL; 1737 char *timewait_sock_slab_name; 1738 int rc = -ENOBUFS; 1739 1740 if (alloc_slab) { 1741 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0, 1742 SLAB_HWCACHE_ALIGN, NULL, NULL); 1743 1744 if (prot->slab == NULL) { 1745 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n", 1746 prot->name); 1747 goto out; 1748 } 1749 1750 if (prot->rsk_prot != NULL) { 1751 static const char mask[] = "request_sock_%s"; 1752 1753 request_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL); 1754 if (request_sock_slab_name == NULL) 1755 goto out_free_sock_slab; 1756 1757 sprintf(request_sock_slab_name, mask, prot->name); 1758 prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name, 1759 prot->rsk_prot->obj_size, 0, 1760 SLAB_HWCACHE_ALIGN, NULL, NULL); 1761 1762 if (prot->rsk_prot->slab == NULL) { 1763 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n", 1764 prot->name); 1765 goto out_free_request_sock_slab_name; 1766 } 1767 } 1768 1769 if (prot->twsk_prot != NULL) { 1770 static const char mask[] = "tw_sock_%s"; 1771 1772 timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL); 1773 1774 if (timewait_sock_slab_name == NULL) 1775 goto out_free_request_sock_slab; 1776 1777 sprintf(timewait_sock_slab_name, mask, prot->name); 1778 prot->twsk_prot->twsk_slab = 1779 kmem_cache_create(timewait_sock_slab_name, 1780 prot->twsk_prot->twsk_obj_size, 1781 0, SLAB_HWCACHE_ALIGN, 1782 NULL, NULL); 1783 if (prot->twsk_prot->twsk_slab == NULL) 1784 goto out_free_timewait_sock_slab_name; 1785 } 1786 } 1787 1788 write_lock(&proto_list_lock); 1789 list_add(&prot->node, &proto_list); 1790 write_unlock(&proto_list_lock); 1791 rc = 0; 1792out: 1793 return rc; 1794out_free_timewait_sock_slab_name: 1795 kfree(timewait_sock_slab_name); 1796out_free_request_sock_slab: 1797 if (prot->rsk_prot && prot->rsk_prot->slab) { 1798 kmem_cache_destroy(prot->rsk_prot->slab); 1799 prot->rsk_prot->slab = NULL; 1800 } 1801out_free_request_sock_slab_name: 1802 kfree(request_sock_slab_name); 1803out_free_sock_slab: 1804 kmem_cache_destroy(prot->slab); 1805 prot->slab = NULL; 1806 goto out; 1807} 1808 1809EXPORT_SYMBOL(proto_register); 1810 1811void proto_unregister(struct proto *prot) 1812{ 1813 write_lock(&proto_list_lock); 1814 list_del(&prot->node); 1815 write_unlock(&proto_list_lock); 1816 1817 if (prot->slab != NULL) { 1818 kmem_cache_destroy(prot->slab); 1819 prot->slab = NULL; 1820 } 1821 1822 if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) { 1823 const char *name = kmem_cache_name(prot->rsk_prot->slab); 1824 1825 kmem_cache_destroy(prot->rsk_prot->slab); 1826 kfree(name); 1827 prot->rsk_prot->slab = NULL; 1828 } 1829 1830 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) { 1831 const char *name = kmem_cache_name(prot->twsk_prot->twsk_slab); 1832 1833 kmem_cache_destroy(prot->twsk_prot->twsk_slab); 1834 kfree(name); 1835 prot->twsk_prot->twsk_slab = NULL; 1836 } 1837} 1838 1839EXPORT_SYMBOL(proto_unregister); 1840 1841#ifdef CONFIG_PROC_FS 1842static inline struct proto *__proto_head(void) 1843{ 1844 return list_entry(proto_list.next, struct proto, node); 1845} 1846 1847static inline struct proto *proto_head(void) 1848{ 1849 return list_empty(&proto_list) ? NULL : __proto_head(); 1850} 1851 1852static inline struct proto *proto_next(struct proto *proto) 1853{ 1854 return proto->node.next == &proto_list ? NULL : 1855 list_entry(proto->node.next, struct proto, node); 1856} 1857 1858static inline struct proto *proto_get_idx(loff_t pos) 1859{ 1860 struct proto *proto; 1861 loff_t i = 0; 1862 1863 list_for_each_entry(proto, &proto_list, node) 1864 if (i++ == pos) 1865 goto out; 1866 1867 proto = NULL; 1868out: 1869 return proto; 1870} 1871 1872static void *proto_seq_start(struct seq_file *seq, loff_t *pos) 1873{ 1874 read_lock(&proto_list_lock); 1875 return *pos ? proto_get_idx(*pos - 1) : SEQ_START_TOKEN; 1876} 1877 1878static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1879{ 1880 ++*pos; 1881 return v == SEQ_START_TOKEN ? proto_head() : proto_next(v); 1882} 1883 1884static void proto_seq_stop(struct seq_file *seq, void *v) 1885{ 1886 read_unlock(&proto_list_lock); 1887} 1888 1889static char proto_method_implemented(const void *method) 1890{ 1891 return method == NULL ? 'n' : 'y'; 1892} 1893 1894static void proto_seq_printf(struct seq_file *seq, struct proto *proto) 1895{ 1896 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s " 1897 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n", 1898 proto->name, 1899 proto->obj_size, 1900 proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1, 1901 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1, 1902 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI", 1903 proto->max_header, 1904 proto->slab == NULL ? "no" : "yes", 1905 module_name(proto->owner), 1906 proto_method_implemented(proto->close), 1907 proto_method_implemented(proto->connect), 1908 proto_method_implemented(proto->disconnect), 1909 proto_method_implemented(proto->accept), 1910 proto_method_implemented(proto->ioctl), 1911 proto_method_implemented(proto->init), 1912 proto_method_implemented(proto->destroy), 1913 proto_method_implemented(proto->shutdown), 1914 proto_method_implemented(proto->setsockopt), 1915 proto_method_implemented(proto->getsockopt), 1916 proto_method_implemented(proto->sendmsg), 1917 proto_method_implemented(proto->recvmsg), 1918 proto_method_implemented(proto->sendpage), 1919 proto_method_implemented(proto->bind), 1920 proto_method_implemented(proto->backlog_rcv), 1921 proto_method_implemented(proto->hash), 1922 proto_method_implemented(proto->unhash), 1923 proto_method_implemented(proto->get_port), 1924 proto_method_implemented(proto->enter_memory_pressure)); 1925} 1926 1927static int proto_seq_show(struct seq_file *seq, void *v) 1928{ 1929 if (v == SEQ_START_TOKEN) 1930 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s", 1931 "protocol", 1932 "size", 1933 "sockets", 1934 "memory", 1935 "press", 1936 "maxhdr", 1937 "slab", 1938 "module", 1939 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n"); 1940 else 1941 proto_seq_printf(seq, v); 1942 return 0; 1943} 1944 1945static const struct seq_operations proto_seq_ops = { 1946 .start = proto_seq_start, 1947 .next = proto_seq_next, 1948 .stop = proto_seq_stop, 1949 .show = proto_seq_show, 1950}; 1951 1952static int proto_seq_open(struct inode *inode, struct file *file) 1953{ 1954 return seq_open(file, &proto_seq_ops); 1955} 1956 1957static const struct file_operations proto_seq_fops = { 1958 .owner = THIS_MODULE, 1959 .open = proto_seq_open, 1960 .read = seq_read, 1961 .llseek = seq_lseek, 1962 .release = seq_release, 1963}; 1964 1965static int __init proto_init(void) 1966{ 1967 /* register /proc/net/protocols */ 1968 return proc_net_fops_create("protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0; 1969} 1970 1971subsys_initcall(proto_init); 1972 1973#endif /* PROC_FS */ 1974 1975EXPORT_SYMBOL(sk_alloc); 1976EXPORT_SYMBOL(sk_free); 1977EXPORT_SYMBOL(sk_send_sigurg); 1978EXPORT_SYMBOL(sock_alloc_send_skb); 1979EXPORT_SYMBOL(sock_init_data); 1980EXPORT_SYMBOL(sock_kfree_s); 1981EXPORT_SYMBOL(sock_kmalloc); 1982EXPORT_SYMBOL(sock_no_accept); 1983EXPORT_SYMBOL(sock_no_bind); 1984EXPORT_SYMBOL(sock_no_connect); 1985EXPORT_SYMBOL(sock_no_getname); 1986EXPORT_SYMBOL(sock_no_getsockopt); 1987EXPORT_SYMBOL(sock_no_ioctl); 1988EXPORT_SYMBOL(sock_no_listen); 1989EXPORT_SYMBOL(sock_no_mmap); 1990EXPORT_SYMBOL(sock_no_poll); 1991EXPORT_SYMBOL(sock_no_recvmsg); 1992EXPORT_SYMBOL(sock_no_sendmsg); 1993EXPORT_SYMBOL(sock_no_sendpage); 1994EXPORT_SYMBOL(sock_no_setsockopt); 1995EXPORT_SYMBOL(sock_no_shutdown); 1996EXPORT_SYMBOL(sock_no_socketpair); 1997EXPORT_SYMBOL(sock_rfree); 1998EXPORT_SYMBOL(sock_setsockopt); 1999EXPORT_SYMBOL(sock_wfree); 2000EXPORT_SYMBOL(sock_wmalloc); 2001EXPORT_SYMBOL(sock_i_uid); 2002EXPORT_SYMBOL(sock_i_ino); 2003EXPORT_SYMBOL(sysctl_optmem_max); 2004#ifdef CONFIG_SYSCTL 2005EXPORT_SYMBOL(sysctl_rmem_max); 2006EXPORT_SYMBOL(sysctl_wmem_max); 2007#endif 2008