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 * Authors:	Ross Biro
  11 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12 *		Florian La Roche, <flla@stud.uni-sb.de>
  13 *		Alan Cox, <A.Cox@swansea.ac.uk>
  14 *
  15 * Fixes:
  16 *		Alan Cox	: 	Numerous verify_area() problems
  17 *		Alan Cox	:	Connecting on a connecting socket
  18 *					now returns an error for tcp.
  19 *		Alan Cox	:	sock->protocol is set correctly.
  20 *					and is not sometimes left as 0.
  21 *		Alan Cox	:	connect handles icmp errors on a
  22 *					connect properly. Unfortunately there
  23 *					is a restart syscall nasty there. I
  24 *					can't match BSD without hacking the C
  25 *					library. Ideas urgently sought!
  26 *		Alan Cox	:	Disallow bind() to addresses that are
  27 *					not ours - especially broadcast ones!!
  28 *		Alan Cox	:	Socket 1024 _IS_ ok for users. (fencepost)
  29 *		Alan Cox	:	sock_wfree/sock_rfree don't destroy sockets,
  30 *					instead they leave that for the DESTROY timer.
  31 *		Alan Cox	:	Clean up error flag in accept
  32 *		Alan Cox	:	TCP ack handling is buggy, the DESTROY timer
  33 *					was buggy. Put a remove_sock() in the handler
  34 *					for memory when we hit 0. Also altered the timer
  35 *					code. The ACK stuff can wait and needs major
  36 *					TCP layer surgery.
  37 *		Alan Cox	:	Fixed TCP ack bug, removed remove sock
  38 *					and fixed timer/inet_bh race.
  39 *		Alan Cox	:	Added zapped flag for TCP
  40 *		Alan Cox	:	Move kfree_skb into skbuff.c and tidied up surplus code
  41 *		Alan Cox	:	for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
  42 *		Alan Cox	:	kfree_s calls now are kfree_skbmem so we can track skb resources
  43 *		Alan Cox	:	Supports socket option broadcast now as does udp. Packet and raw need fixing.
  44 *		Alan Cox	:	Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
  45 *		Rick Sladkey	:	Relaxed UDP rules for matching packets.
  46 *		C.E.Hawkins	:	IFF_PROMISC/SIOCGHWADDR support
  47 *	Pauline Middelink	:	identd support
  48 *		Alan Cox	:	Fixed connect() taking signals I think.
  49 *		Alan Cox	:	SO_LINGER supported
  50 *		Alan Cox	:	Error reporting fixes
  51 *		Anonymous	:	inet_create tidied up (sk->reuse setting)
  52 *		Alan Cox	:	inet sockets don't set sk->type!
  53 *		Alan Cox	:	Split socket option code
  54 *		Alan Cox	:	Callbacks
  55 *		Alan Cox	:	Nagle flag for Charles & Johannes stuff
  56 *		Alex		:	Removed restriction on inet fioctl
  57 *		Alan Cox	:	Splitting INET from NET core
  58 *		Alan Cox	:	Fixed bogus SO_TYPE handling in getsockopt()
  59 *		Adam Caldwell	:	Missing return in SO_DONTROUTE/SO_DEBUG code
  60 *		Alan Cox	:	Split IP from generic code
  61 *		Alan Cox	:	New kfree_skbmem()
  62 *		Alan Cox	:	Make SO_DEBUG superuser only.
  63 *		Alan Cox	:	Allow anyone to clear SO_DEBUG
  64 *					(compatibility fix)
  65 *		Alan Cox	:	Added optimistic memory grabbing for AF_UNIX throughput.
  66 *		Alan Cox	:	Allocator for a socket is settable.
  67 *		Alan Cox	:	SO_ERROR includes soft errors.
  68 *		Alan Cox	:	Allow NULL arguments on some SO_ opts
  69 *		Alan Cox	: 	Generic socket allocation to make hooks
  70 *					easier (suggested by Craig Metz).
  71 *		Michael Pall	:	SO_ERROR returns positive errno again
  72 *              Steve Whitehouse:       Added default destructor to free
  73 *                                      protocol private data.
  74 *              Steve Whitehouse:       Added various other default routines
  75 *                                      common to several socket families.
  76 *              Chris Evans     :       Call suser() check last on F_SETOWN
  77 *		Jay Schulist	:	Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
  78 *		Andi Kleen	:	Add sock_kmalloc()/sock_kfree_s()
  79 *		Andi Kleen	:	Fix write_space callback
  80 *		Chris Evans	:	Security fixes - signedness again
  81 *		Arnaldo C. Melo :       cleanups, use skb_queue_purge
  82 *
  83 * To Fix:
  84 *
  85 *
  86 *		This program is free software; you can redistribute it and/or
  87 *		modify it under the terms of the GNU General Public License
  88 *		as published by the Free Software Foundation; either version
  89 *		2 of the License, or (at your option) any later version.
  90 */
  91
 
 
  92#include <linux/capability.h>
  93#include <linux/errno.h>
  94#include <linux/types.h>
  95#include <linux/socket.h>
  96#include <linux/in.h>
  97#include <linux/kernel.h>
  98#include <linux/module.h>
  99#include <linux/proc_fs.h>
 100#include <linux/seq_file.h>
 101#include <linux/sched.h>
 102#include <linux/timer.h>
 103#include <linux/string.h>
 104#include <linux/sockios.h>
 105#include <linux/net.h>
 106#include <linux/mm.h>
 107#include <linux/slab.h>
 108#include <linux/interrupt.h>
 109#include <linux/poll.h>
 110#include <linux/tcp.h>
 111#include <linux/init.h>
 112#include <linux/highmem.h>
 113#include <linux/user_namespace.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/net_namespace.h>
 122#include <net/request_sock.h>
 123#include <net/sock.h>
 124#include <linux/net_tstamp.h>
 125#include <net/xfrm.h>
 126#include <linux/ipsec.h>
 127#include <net/cls_cgroup.h>
 
 128
 129#include <linux/filter.h>
 130
 131#include <trace/events/sock.h>
 132
 133#ifdef CONFIG_INET
 134#include <net/tcp.h>
 135#endif
 136
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 137/*
 138 * Each address family might have different locking rules, so we have
 139 * one slock key per address family:
 140 */
 141static struct lock_class_key af_family_keys[AF_MAX];
 142static struct lock_class_key af_family_slock_keys[AF_MAX];
 143
 
 
 
 144/*
 145 * Make lock validator output more readable. (we pre-construct these
 146 * strings build-time, so that runtime initialization of socket
 147 * locks is fast):
 148 */
 149static const char *const af_family_key_strings[AF_MAX+1] = {
 150  "sk_lock-AF_UNSPEC", "sk_lock-AF_UNIX"     , "sk_lock-AF_INET"     ,
 151  "sk_lock-AF_AX25"  , "sk_lock-AF_IPX"      , "sk_lock-AF_APPLETALK",
 152  "sk_lock-AF_NETROM", "sk_lock-AF_BRIDGE"   , "sk_lock-AF_ATMPVC"   ,
 153  "sk_lock-AF_X25"   , "sk_lock-AF_INET6"    , "sk_lock-AF_ROSE"     ,
 154  "sk_lock-AF_DECnet", "sk_lock-AF_NETBEUI"  , "sk_lock-AF_SECURITY" ,
 155  "sk_lock-AF_KEY"   , "sk_lock-AF_NETLINK"  , "sk_lock-AF_PACKET"   ,
 156  "sk_lock-AF_ASH"   , "sk_lock-AF_ECONET"   , "sk_lock-AF_ATMSVC"   ,
 157  "sk_lock-AF_RDS"   , "sk_lock-AF_SNA"      , "sk_lock-AF_IRDA"     ,
 158  "sk_lock-AF_PPPOX" , "sk_lock-AF_WANPIPE"  , "sk_lock-AF_LLC"      ,
 159  "sk_lock-27"       , "sk_lock-28"          , "sk_lock-AF_CAN"      ,
 160  "sk_lock-AF_TIPC"  , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV"        ,
 161  "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN"     , "sk_lock-AF_PHONET"   ,
 162  "sk_lock-AF_IEEE802154", "sk_lock-AF_CAIF" , "sk_lock-AF_ALG"      ,
 163  "sk_lock-AF_NFC"   , "sk_lock-AF_MAX"
 164};
 165static const char *const af_family_slock_key_strings[AF_MAX+1] = {
 166  "slock-AF_UNSPEC", "slock-AF_UNIX"     , "slock-AF_INET"     ,
 167  "slock-AF_AX25"  , "slock-AF_IPX"      , "slock-AF_APPLETALK",
 168  "slock-AF_NETROM", "slock-AF_BRIDGE"   , "slock-AF_ATMPVC"   ,
 169  "slock-AF_X25"   , "slock-AF_INET6"    , "slock-AF_ROSE"     ,
 170  "slock-AF_DECnet", "slock-AF_NETBEUI"  , "slock-AF_SECURITY" ,
 171  "slock-AF_KEY"   , "slock-AF_NETLINK"  , "slock-AF_PACKET"   ,
 172  "slock-AF_ASH"   , "slock-AF_ECONET"   , "slock-AF_ATMSVC"   ,
 173  "slock-AF_RDS"   , "slock-AF_SNA"      , "slock-AF_IRDA"     ,
 174  "slock-AF_PPPOX" , "slock-AF_WANPIPE"  , "slock-AF_LLC"      ,
 175  "slock-27"       , "slock-28"          , "slock-AF_CAN"      ,
 176  "slock-AF_TIPC"  , "slock-AF_BLUETOOTH", "slock-AF_IUCV"     ,
 177  "slock-AF_RXRPC" , "slock-AF_ISDN"     , "slock-AF_PHONET"   ,
 178  "slock-AF_IEEE802154", "slock-AF_CAIF" , "slock-AF_ALG"      ,
 179  "slock-AF_NFC"   , "slock-AF_MAX"
 180};
 181static const char *const af_family_clock_key_strings[AF_MAX+1] = {
 182  "clock-AF_UNSPEC", "clock-AF_UNIX"     , "clock-AF_INET"     ,
 183  "clock-AF_AX25"  , "clock-AF_IPX"      , "clock-AF_APPLETALK",
 184  "clock-AF_NETROM", "clock-AF_BRIDGE"   , "clock-AF_ATMPVC"   ,
 185  "clock-AF_X25"   , "clock-AF_INET6"    , "clock-AF_ROSE"     ,
 186  "clock-AF_DECnet", "clock-AF_NETBEUI"  , "clock-AF_SECURITY" ,
 187  "clock-AF_KEY"   , "clock-AF_NETLINK"  , "clock-AF_PACKET"   ,
 188  "clock-AF_ASH"   , "clock-AF_ECONET"   , "clock-AF_ATMSVC"   ,
 189  "clock-AF_RDS"   , "clock-AF_SNA"      , "clock-AF_IRDA"     ,
 190  "clock-AF_PPPOX" , "clock-AF_WANPIPE"  , "clock-AF_LLC"      ,
 191  "clock-27"       , "clock-28"          , "clock-AF_CAN"      ,
 192  "clock-AF_TIPC"  , "clock-AF_BLUETOOTH", "clock-AF_IUCV"     ,
 193  "clock-AF_RXRPC" , "clock-AF_ISDN"     , "clock-AF_PHONET"   ,
 194  "clock-AF_IEEE802154", "clock-AF_CAIF" , "clock-AF_ALG"      ,
 195  "clock-AF_NFC"   , "clock-AF_MAX"
 196};
 197
 198/*
 199 * sk_callback_lock locking rules are per-address-family,
 200 * so split the lock classes by using a per-AF key:
 201 */
 202static struct lock_class_key af_callback_keys[AF_MAX];
 203
 204/* Take into consideration the size of the struct sk_buff overhead in the
 205 * determination of these values, since that is non-constant across
 206 * platforms.  This makes socket queueing behavior and performance
 207 * not depend upon such differences.
 208 */
 209#define _SK_MEM_PACKETS		256
 210#define _SK_MEM_OVERHEAD	(sizeof(struct sk_buff) + 256)
 211#define SK_WMEM_MAX		(_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
 212#define SK_RMEM_MAX		(_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
 213
 214/* Run time adjustable parameters. */
 215__u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
 
 216__u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
 
 217__u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
 218__u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
 219
 220/* Maximal space eaten by iovec or ancillary data plus some space */
 221int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
 222EXPORT_SYMBOL(sysctl_optmem_max);
 223
 224#if defined(CONFIG_CGROUPS) && !defined(CONFIG_NET_CLS_CGROUP)
 
 225int net_cls_subsys_id = -1;
 226EXPORT_SYMBOL_GPL(net_cls_subsys_id);
 227#endif
 
 
 
 
 
 228
 229static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
 230{
 231	struct timeval tv;
 232
 233	if (optlen < sizeof(tv))
 234		return -EINVAL;
 235	if (copy_from_user(&tv, optval, sizeof(tv)))
 236		return -EFAULT;
 237	if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
 238		return -EDOM;
 239
 240	if (tv.tv_sec < 0) {
 241		static int warned __read_mostly;
 242
 243		*timeo_p = 0;
 244		if (warned < 10 && net_ratelimit()) {
 245			warned++;
 246			printk(KERN_INFO "sock_set_timeout: `%s' (pid %d) "
 247			       "tries to set negative timeout\n",
 248				current->comm, task_pid_nr(current));
 249		}
 250		return 0;
 251	}
 252	*timeo_p = MAX_SCHEDULE_TIMEOUT;
 253	if (tv.tv_sec == 0 && tv.tv_usec == 0)
 254		return 0;
 255	if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
 256		*timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
 257	return 0;
 258}
 259
 260static void sock_warn_obsolete_bsdism(const char *name)
 261{
 262	static int warned;
 263	static char warncomm[TASK_COMM_LEN];
 264	if (strcmp(warncomm, current->comm) && warned < 5) {
 265		strcpy(warncomm,  current->comm);
 266		printk(KERN_WARNING "process `%s' is using obsolete "
 267		       "%s SO_BSDCOMPAT\n", warncomm, name);
 268		warned++;
 269	}
 270}
 271
 272static void sock_disable_timestamp(struct sock *sk, int flag)
 
 
 273{
 274	if (sock_flag(sk, flag)) {
 275		sock_reset_flag(sk, flag);
 276		if (!sock_flag(sk, SOCK_TIMESTAMP) &&
 277		    !sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE)) {
 278			net_disable_timestamp();
 279		}
 280	}
 281}
 282
 283
 284int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
 285{
 286	int err;
 287	int skb_len;
 288	unsigned long flags;
 289	struct sk_buff_head *list = &sk->sk_receive_queue;
 290
 291	/* Cast sk->rcvbuf to unsigned... It's pointless, but reduces
 292	   number of warnings when compiling with -W --ANK
 293	 */
 294	if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
 295	    (unsigned)sk->sk_rcvbuf) {
 296		atomic_inc(&sk->sk_drops);
 297		trace_sock_rcvqueue_full(sk, skb);
 298		return -ENOMEM;
 299	}
 300
 301	err = sk_filter(sk, skb);
 302	if (err)
 303		return err;
 304
 305	if (!sk_rmem_schedule(sk, skb->truesize)) {
 306		atomic_inc(&sk->sk_drops);
 307		return -ENOBUFS;
 308	}
 309
 310	skb->dev = NULL;
 311	skb_set_owner_r(skb, sk);
 312
 313	/* Cache the SKB length before we tack it onto the receive
 314	 * queue.  Once it is added it no longer belongs to us and
 315	 * may be freed by other threads of control pulling packets
 316	 * from the queue.
 317	 */
 318	skb_len = skb->len;
 319
 320	/* we escape from rcu protected region, make sure we dont leak
 321	 * a norefcounted dst
 322	 */
 323	skb_dst_force(skb);
 324
 325	spin_lock_irqsave(&list->lock, flags);
 326	skb->dropcount = atomic_read(&sk->sk_drops);
 327	__skb_queue_tail(list, skb);
 328	spin_unlock_irqrestore(&list->lock, flags);
 329
 330	if (!sock_flag(sk, SOCK_DEAD))
 331		sk->sk_data_ready(sk, skb_len);
 332	return 0;
 333}
 334EXPORT_SYMBOL(sock_queue_rcv_skb);
 335
 336int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested)
 337{
 338	int rc = NET_RX_SUCCESS;
 339
 340	if (sk_filter(sk, skb))
 341		goto discard_and_relse;
 342
 343	skb->dev = NULL;
 344
 345	if (sk_rcvqueues_full(sk, skb)) {
 346		atomic_inc(&sk->sk_drops);
 347		goto discard_and_relse;
 348	}
 349	if (nested)
 350		bh_lock_sock_nested(sk);
 351	else
 352		bh_lock_sock(sk);
 353	if (!sock_owned_by_user(sk)) {
 354		/*
 355		 * trylock + unlock semantics:
 356		 */
 357		mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
 358
 359		rc = sk_backlog_rcv(sk, skb);
 360
 361		mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
 362	} else if (sk_add_backlog(sk, skb)) {
 363		bh_unlock_sock(sk);
 364		atomic_inc(&sk->sk_drops);
 365		goto discard_and_relse;
 366	}
 367
 368	bh_unlock_sock(sk);
 369out:
 370	sock_put(sk);
 371	return rc;
 372discard_and_relse:
 373	kfree_skb(skb);
 374	goto out;
 375}
 376EXPORT_SYMBOL(sk_receive_skb);
 377
 378void sk_reset_txq(struct sock *sk)
 379{
 380	sk_tx_queue_clear(sk);
 381}
 382EXPORT_SYMBOL(sk_reset_txq);
 383
 384struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
 385{
 386	struct dst_entry *dst = __sk_dst_get(sk);
 387
 388	if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
 389		sk_tx_queue_clear(sk);
 390		rcu_assign_pointer(sk->sk_dst_cache, NULL);
 391		dst_release(dst);
 392		return NULL;
 393	}
 394
 395	return dst;
 396}
 397EXPORT_SYMBOL(__sk_dst_check);
 398
 399struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
 400{
 401	struct dst_entry *dst = sk_dst_get(sk);
 402
 403	if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
 404		sk_dst_reset(sk);
 405		dst_release(dst);
 406		return NULL;
 407	}
 408
 409	return dst;
 410}
 411EXPORT_SYMBOL(sk_dst_check);
 412
 413static int sock_bindtodevice(struct sock *sk, char __user *optval, int optlen)
 414{
 415	int ret = -ENOPROTOOPT;
 416#ifdef CONFIG_NETDEVICES
 417	struct net *net = sock_net(sk);
 418	char devname[IFNAMSIZ];
 419	int index;
 420
 421	/* Sorry... */
 422	ret = -EPERM;
 423	if (!capable(CAP_NET_RAW))
 424		goto out;
 425
 426	ret = -EINVAL;
 427	if (optlen < 0)
 428		goto out;
 429
 430	/* Bind this socket to a particular device like "eth0",
 431	 * as specified in the passed interface name. If the
 432	 * name is "" or the option length is zero the socket
 433	 * is not bound.
 434	 */
 435	if (optlen > IFNAMSIZ - 1)
 436		optlen = IFNAMSIZ - 1;
 437	memset(devname, 0, sizeof(devname));
 438
 439	ret = -EFAULT;
 440	if (copy_from_user(devname, optval, optlen))
 441		goto out;
 442
 443	index = 0;
 444	if (devname[0] != '\0') {
 445		struct net_device *dev;
 446
 447		rcu_read_lock();
 448		dev = dev_get_by_name_rcu(net, devname);
 449		if (dev)
 450			index = dev->ifindex;
 451		rcu_read_unlock();
 452		ret = -ENODEV;
 453		if (!dev)
 454			goto out;
 455	}
 456
 457	lock_sock(sk);
 458	sk->sk_bound_dev_if = index;
 459	sk_dst_reset(sk);
 460	release_sock(sk);
 461
 462	ret = 0;
 463
 464out:
 465#endif
 466
 467	return ret;
 468}
 469
 470static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
 471{
 472	if (valbool)
 473		sock_set_flag(sk, bit);
 474	else
 475		sock_reset_flag(sk, bit);
 476}
 477
 478/*
 479 *	This is meant for all protocols to use and covers goings on
 480 *	at the socket level. Everything here is generic.
 481 */
 482
 483int sock_setsockopt(struct socket *sock, int level, int optname,
 484		    char __user *optval, unsigned int optlen)
 485{
 486	struct sock *sk = sock->sk;
 487	int val;
 488	int valbool;
 489	struct linger ling;
 490	int ret = 0;
 491
 492	/*
 493	 *	Options without arguments
 494	 */
 495
 496	if (optname == SO_BINDTODEVICE)
 497		return sock_bindtodevice(sk, optval, optlen);
 498
 499	if (optlen < sizeof(int))
 500		return -EINVAL;
 501
 502	if (get_user(val, (int __user *)optval))
 503		return -EFAULT;
 504
 505	valbool = val ? 1 : 0;
 506
 507	lock_sock(sk);
 508
 509	switch (optname) {
 510	case SO_DEBUG:
 511		if (val && !capable(CAP_NET_ADMIN))
 512			ret = -EACCES;
 513		else
 514			sock_valbool_flag(sk, SOCK_DBG, valbool);
 515		break;
 516	case SO_REUSEADDR:
 517		sk->sk_reuse = valbool;
 518		break;
 519	case SO_TYPE:
 520	case SO_PROTOCOL:
 521	case SO_DOMAIN:
 522	case SO_ERROR:
 523		ret = -ENOPROTOOPT;
 524		break;
 525	case SO_DONTROUTE:
 526		sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
 527		break;
 528	case SO_BROADCAST:
 529		sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
 530		break;
 531	case SO_SNDBUF:
 532		/* Don't error on this BSD doesn't and if you think
 533		   about it this is right. Otherwise apps have to
 534		   play 'guess the biggest size' games. RCVBUF/SNDBUF
 535		   are treated in BSD as hints */
 536
 537		if (val > sysctl_wmem_max)
 538			val = sysctl_wmem_max;
 539set_sndbuf:
 540		sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
 541		if ((val * 2) < SOCK_MIN_SNDBUF)
 542			sk->sk_sndbuf = SOCK_MIN_SNDBUF;
 543		else
 544			sk->sk_sndbuf = val * 2;
 545
 546		/*
 547		 *	Wake up sending tasks if we
 548		 *	upped the value.
 549		 */
 550		sk->sk_write_space(sk);
 551		break;
 552
 553	case SO_SNDBUFFORCE:
 554		if (!capable(CAP_NET_ADMIN)) {
 555			ret = -EPERM;
 556			break;
 557		}
 558		goto set_sndbuf;
 559
 560	case SO_RCVBUF:
 561		/* Don't error on this BSD doesn't and if you think
 562		   about it this is right. Otherwise apps have to
 563		   play 'guess the biggest size' games. RCVBUF/SNDBUF
 564		   are treated in BSD as hints */
 565
 566		if (val > sysctl_rmem_max)
 567			val = sysctl_rmem_max;
 568set_rcvbuf:
 569		sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
 570		/*
 571		 * We double it on the way in to account for
 572		 * "struct sk_buff" etc. overhead.   Applications
 573		 * assume that the SO_RCVBUF setting they make will
 574		 * allow that much actual data to be received on that
 575		 * socket.
 576		 *
 577		 * Applications are unaware that "struct sk_buff" and
 578		 * other overheads allocate from the receive buffer
 579		 * during socket buffer allocation.
 580		 *
 581		 * And after considering the possible alternatives,
 582		 * returning the value we actually used in getsockopt
 583		 * is the most desirable behavior.
 584		 */
 585		if ((val * 2) < SOCK_MIN_RCVBUF)
 586			sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
 587		else
 588			sk->sk_rcvbuf = val * 2;
 589		break;
 590
 591	case SO_RCVBUFFORCE:
 592		if (!capable(CAP_NET_ADMIN)) {
 593			ret = -EPERM;
 594			break;
 595		}
 596		goto set_rcvbuf;
 597
 598	case SO_KEEPALIVE:
 599#ifdef CONFIG_INET
 600		if (sk->sk_protocol == IPPROTO_TCP)
 601			tcp_set_keepalive(sk, valbool);
 602#endif
 603		sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
 604		break;
 605
 606	case SO_OOBINLINE:
 607		sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
 608		break;
 609
 610	case SO_NO_CHECK:
 611		sk->sk_no_check = valbool;
 612		break;
 613
 614	case SO_PRIORITY:
 615		if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
 616			sk->sk_priority = val;
 617		else
 618			ret = -EPERM;
 619		break;
 620
 621	case SO_LINGER:
 622		if (optlen < sizeof(ling)) {
 623			ret = -EINVAL;	/* 1003.1g */
 624			break;
 625		}
 626		if (copy_from_user(&ling, optval, sizeof(ling))) {
 627			ret = -EFAULT;
 628			break;
 629		}
 630		if (!ling.l_onoff)
 631			sock_reset_flag(sk, SOCK_LINGER);
 632		else {
 633#if (BITS_PER_LONG == 32)
 634			if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
 635				sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
 636			else
 637#endif
 638				sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
 639			sock_set_flag(sk, SOCK_LINGER);
 640		}
 641		break;
 642
 643	case SO_BSDCOMPAT:
 644		sock_warn_obsolete_bsdism("setsockopt");
 645		break;
 646
 647	case SO_PASSCRED:
 648		if (valbool)
 649			set_bit(SOCK_PASSCRED, &sock->flags);
 650		else
 651			clear_bit(SOCK_PASSCRED, &sock->flags);
 652		break;
 653
 654	case SO_TIMESTAMP:
 655	case SO_TIMESTAMPNS:
 656		if (valbool)  {
 657			if (optname == SO_TIMESTAMP)
 658				sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
 659			else
 660				sock_set_flag(sk, SOCK_RCVTSTAMPNS);
 661			sock_set_flag(sk, SOCK_RCVTSTAMP);
 662			sock_enable_timestamp(sk, SOCK_TIMESTAMP);
 663		} else {
 664			sock_reset_flag(sk, SOCK_RCVTSTAMP);
 665			sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
 666		}
 667		break;
 668
 669	case SO_TIMESTAMPING:
 670		if (val & ~SOF_TIMESTAMPING_MASK) {
 671			ret = -EINVAL;
 672			break;
 673		}
 674		sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE,
 675				  val & SOF_TIMESTAMPING_TX_HARDWARE);
 676		sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE,
 677				  val & SOF_TIMESTAMPING_TX_SOFTWARE);
 678		sock_valbool_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE,
 679				  val & SOF_TIMESTAMPING_RX_HARDWARE);
 680		if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
 681			sock_enable_timestamp(sk,
 682					      SOCK_TIMESTAMPING_RX_SOFTWARE);
 683		else
 684			sock_disable_timestamp(sk,
 685					       SOCK_TIMESTAMPING_RX_SOFTWARE);
 686		sock_valbool_flag(sk, SOCK_TIMESTAMPING_SOFTWARE,
 687				  val & SOF_TIMESTAMPING_SOFTWARE);
 688		sock_valbool_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE,
 689				  val & SOF_TIMESTAMPING_SYS_HARDWARE);
 690		sock_valbool_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE,
 691				  val & SOF_TIMESTAMPING_RAW_HARDWARE);
 692		break;
 693
 694	case SO_RCVLOWAT:
 695		if (val < 0)
 696			val = INT_MAX;
 697		sk->sk_rcvlowat = val ? : 1;
 698		break;
 699
 700	case SO_RCVTIMEO:
 701		ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
 702		break;
 703
 704	case SO_SNDTIMEO:
 705		ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
 706		break;
 707
 708	case SO_ATTACH_FILTER:
 709		ret = -EINVAL;
 710		if (optlen == sizeof(struct sock_fprog)) {
 711			struct sock_fprog fprog;
 712
 713			ret = -EFAULT;
 714			if (copy_from_user(&fprog, optval, sizeof(fprog)))
 715				break;
 716
 717			ret = sk_attach_filter(&fprog, sk);
 718		}
 719		break;
 720
 721	case SO_DETACH_FILTER:
 722		ret = sk_detach_filter(sk);
 723		break;
 724
 725	case SO_PASSSEC:
 726		if (valbool)
 727			set_bit(SOCK_PASSSEC, &sock->flags);
 728		else
 729			clear_bit(SOCK_PASSSEC, &sock->flags);
 730		break;
 731	case SO_MARK:
 732		if (!capable(CAP_NET_ADMIN))
 733			ret = -EPERM;
 734		else
 735			sk->sk_mark = val;
 736		break;
 737
 738		/* We implement the SO_SNDLOWAT etc to
 739		   not be settable (1003.1g 5.3) */
 740	case SO_RXQ_OVFL:
 741		if (valbool)
 742			sock_set_flag(sk, SOCK_RXQ_OVFL);
 
 
 
 
 
 
 
 
 743		else
 744			sock_reset_flag(sk, SOCK_RXQ_OVFL);
 745		break;
 
 
 
 
 
 746	default:
 747		ret = -ENOPROTOOPT;
 748		break;
 749	}
 750	release_sock(sk);
 751	return ret;
 752}
 753EXPORT_SYMBOL(sock_setsockopt);
 754
 755
 756void cred_to_ucred(struct pid *pid, const struct cred *cred,
 757		   struct ucred *ucred)
 758{
 759	ucred->pid = pid_vnr(pid);
 760	ucred->uid = ucred->gid = -1;
 761	if (cred) {
 762		struct user_namespace *current_ns = current_user_ns();
 763
 764		ucred->uid = user_ns_map_uid(current_ns, cred, cred->euid);
 765		ucred->gid = user_ns_map_gid(current_ns, cred, cred->egid);
 766	}
 767}
 768EXPORT_SYMBOL_GPL(cred_to_ucred);
 769
 770int sock_getsockopt(struct socket *sock, int level, int optname,
 771		    char __user *optval, int __user *optlen)
 772{
 773	struct sock *sk = sock->sk;
 774
 775	union {
 776		int val;
 777		struct linger ling;
 778		struct timeval tm;
 779	} v;
 780
 781	int lv = sizeof(int);
 782	int len;
 783
 784	if (get_user(len, optlen))
 785		return -EFAULT;
 786	if (len < 0)
 787		return -EINVAL;
 788
 789	memset(&v, 0, sizeof(v));
 790
 791	switch (optname) {
 792	case SO_DEBUG:
 793		v.val = sock_flag(sk, SOCK_DBG);
 794		break;
 795
 796	case SO_DONTROUTE:
 797		v.val = sock_flag(sk, SOCK_LOCALROUTE);
 798		break;
 799
 800	case SO_BROADCAST:
 801		v.val = !!sock_flag(sk, SOCK_BROADCAST);
 802		break;
 803
 804	case SO_SNDBUF:
 805		v.val = sk->sk_sndbuf;
 806		break;
 807
 808	case SO_RCVBUF:
 809		v.val = sk->sk_rcvbuf;
 810		break;
 811
 812	case SO_REUSEADDR:
 813		v.val = sk->sk_reuse;
 814		break;
 815
 816	case SO_KEEPALIVE:
 817		v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
 818		break;
 819
 820	case SO_TYPE:
 821		v.val = sk->sk_type;
 822		break;
 823
 824	case SO_PROTOCOL:
 825		v.val = sk->sk_protocol;
 826		break;
 827
 828	case SO_DOMAIN:
 829		v.val = sk->sk_family;
 830		break;
 831
 832	case SO_ERROR:
 833		v.val = -sock_error(sk);
 834		if (v.val == 0)
 835			v.val = xchg(&sk->sk_err_soft, 0);
 836		break;
 837
 838	case SO_OOBINLINE:
 839		v.val = !!sock_flag(sk, SOCK_URGINLINE);
 840		break;
 841
 842	case SO_NO_CHECK:
 843		v.val = sk->sk_no_check;
 844		break;
 845
 846	case SO_PRIORITY:
 847		v.val = sk->sk_priority;
 848		break;
 849
 850	case SO_LINGER:
 851		lv		= sizeof(v.ling);
 852		v.ling.l_onoff	= !!sock_flag(sk, SOCK_LINGER);
 853		v.ling.l_linger	= sk->sk_lingertime / HZ;
 854		break;
 855
 856	case SO_BSDCOMPAT:
 857		sock_warn_obsolete_bsdism("getsockopt");
 858		break;
 859
 860	case SO_TIMESTAMP:
 861		v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
 862				!sock_flag(sk, SOCK_RCVTSTAMPNS);
 863		break;
 864
 865	case SO_TIMESTAMPNS:
 866		v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
 867		break;
 868
 869	case SO_TIMESTAMPING:
 870		v.val = 0;
 871		if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE))
 872			v.val |= SOF_TIMESTAMPING_TX_HARDWARE;
 873		if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE))
 874			v.val |= SOF_TIMESTAMPING_TX_SOFTWARE;
 875		if (sock_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE))
 876			v.val |= SOF_TIMESTAMPING_RX_HARDWARE;
 877		if (sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE))
 878			v.val |= SOF_TIMESTAMPING_RX_SOFTWARE;
 879		if (sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE))
 880			v.val |= SOF_TIMESTAMPING_SOFTWARE;
 881		if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE))
 882			v.val |= SOF_TIMESTAMPING_SYS_HARDWARE;
 883		if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE))
 884			v.val |= SOF_TIMESTAMPING_RAW_HARDWARE;
 885		break;
 886
 887	case SO_RCVTIMEO:
 888		lv = sizeof(struct timeval);
 889		if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
 890			v.tm.tv_sec = 0;
 891			v.tm.tv_usec = 0;
 892		} else {
 893			v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
 894			v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
 895		}
 896		break;
 897
 898	case SO_SNDTIMEO:
 899		lv = sizeof(struct timeval);
 900		if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
 901			v.tm.tv_sec = 0;
 902			v.tm.tv_usec = 0;
 903		} else {
 904			v.tm.tv_sec = sk->sk_sndtimeo / HZ;
 905			v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
 906		}
 907		break;
 908
 909	case SO_RCVLOWAT:
 910		v.val = sk->sk_rcvlowat;
 911		break;
 912
 913	case SO_SNDLOWAT:
 914		v.val = 1;
 915		break;
 916
 917	case SO_PASSCRED:
 918		v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
 919		break;
 920
 921	case SO_PEERCRED:
 922	{
 923		struct ucred peercred;
 924		if (len > sizeof(peercred))
 925			len = sizeof(peercred);
 926		cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred, &peercred);
 927		if (copy_to_user(optval, &peercred, len))
 928			return -EFAULT;
 929		goto lenout;
 930	}
 931
 932	case SO_PEERNAME:
 933	{
 934		char address[128];
 935
 936		if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
 937			return -ENOTCONN;
 938		if (lv < len)
 939			return -EINVAL;
 940		if (copy_to_user(optval, address, len))
 941			return -EFAULT;
 942		goto lenout;
 943	}
 944
 945	/* Dubious BSD thing... Probably nobody even uses it, but
 946	 * the UNIX standard wants it for whatever reason... -DaveM
 947	 */
 948	case SO_ACCEPTCONN:
 949		v.val = sk->sk_state == TCP_LISTEN;
 950		break;
 951
 952	case SO_PASSSEC:
 953		v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0;
 954		break;
 955
 956	case SO_PEERSEC:
 957		return security_socket_getpeersec_stream(sock, optval, optlen, len);
 958
 959	case SO_MARK:
 960		v.val = sk->sk_mark;
 961		break;
 962
 963	case SO_RXQ_OVFL:
 964		v.val = !!sock_flag(sk, SOCK_RXQ_OVFL);
 
 
 
 
 965		break;
 966
 
 
 
 
 
 
 
 
 
 967	default:
 968		return -ENOPROTOOPT;
 969	}
 970
 971	if (len > lv)
 972		len = lv;
 973	if (copy_to_user(optval, &v, len))
 974		return -EFAULT;
 975lenout:
 976	if (put_user(len, optlen))
 977		return -EFAULT;
 978	return 0;
 979}
 980
 981/*
 982 * Initialize an sk_lock.
 983 *
 984 * (We also register the sk_lock with the lock validator.)
 985 */
 986static inline void sock_lock_init(struct sock *sk)
 987{
 988	sock_lock_init_class_and_name(sk,
 989			af_family_slock_key_strings[sk->sk_family],
 990			af_family_slock_keys + sk->sk_family,
 991			af_family_key_strings[sk->sk_family],
 992			af_family_keys + sk->sk_family);
 993}
 994
 995/*
 996 * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
 997 * even temporarly, because of RCU lookups. sk_node should also be left as is.
 998 * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
 999 */
1000static void sock_copy(struct sock *nsk, const struct sock *osk)
1001{
1002#ifdef CONFIG_SECURITY_NETWORK
1003	void *sptr = nsk->sk_security;
1004#endif
1005	memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
1006
1007	memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
1008	       osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
1009
1010#ifdef CONFIG_SECURITY_NETWORK
1011	nsk->sk_security = sptr;
1012	security_sk_clone(osk, nsk);
1013#endif
1014}
1015
1016/*
1017 * caches using SLAB_DESTROY_BY_RCU should let .next pointer from nulls nodes
1018 * un-modified. Special care is taken when initializing object to zero.
1019 */
1020static inline void sk_prot_clear_nulls(struct sock *sk, int size)
1021{
1022	if (offsetof(struct sock, sk_node.next) != 0)
1023		memset(sk, 0, offsetof(struct sock, sk_node.next));
1024	memset(&sk->sk_node.pprev, 0,
1025	       size - offsetof(struct sock, sk_node.pprev));
1026}
1027
1028void sk_prot_clear_portaddr_nulls(struct sock *sk, int size)
1029{
1030	unsigned long nulls1, nulls2;
1031
1032	nulls1 = offsetof(struct sock, __sk_common.skc_node.next);
1033	nulls2 = offsetof(struct sock, __sk_common.skc_portaddr_node.next);
1034	if (nulls1 > nulls2)
1035		swap(nulls1, nulls2);
1036
1037	if (nulls1 != 0)
1038		memset((char *)sk, 0, nulls1);
1039	memset((char *)sk + nulls1 + sizeof(void *), 0,
1040	       nulls2 - nulls1 - sizeof(void *));
1041	memset((char *)sk + nulls2 + sizeof(void *), 0,
1042	       size - nulls2 - sizeof(void *));
1043}
1044EXPORT_SYMBOL(sk_prot_clear_portaddr_nulls);
1045
1046static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
1047		int family)
1048{
1049	struct sock *sk;
1050	struct kmem_cache *slab;
1051
1052	slab = prot->slab;
1053	if (slab != NULL) {
1054		sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
1055		if (!sk)
1056			return sk;
1057		if (priority & __GFP_ZERO) {
1058			if (prot->clear_sk)
1059				prot->clear_sk(sk, prot->obj_size);
1060			else
1061				sk_prot_clear_nulls(sk, prot->obj_size);
1062		}
1063	} else
1064		sk = kmalloc(prot->obj_size, priority);
1065
1066	if (sk != NULL) {
1067		kmemcheck_annotate_bitfield(sk, flags);
1068
1069		if (security_sk_alloc(sk, family, priority))
1070			goto out_free;
1071
1072		if (!try_module_get(prot->owner))
1073			goto out_free_sec;
1074		sk_tx_queue_clear(sk);
1075	}
1076
1077	return sk;
1078
1079out_free_sec:
1080	security_sk_free(sk);
1081out_free:
1082	if (slab != NULL)
1083		kmem_cache_free(slab, sk);
1084	else
1085		kfree(sk);
1086	return NULL;
1087}
1088
1089static void sk_prot_free(struct proto *prot, struct sock *sk)
1090{
1091	struct kmem_cache *slab;
1092	struct module *owner;
1093
1094	owner = prot->owner;
1095	slab = prot->slab;
1096
1097	security_sk_free(sk);
1098	if (slab != NULL)
1099		kmem_cache_free(slab, sk);
1100	else
1101		kfree(sk);
1102	module_put(owner);
1103}
1104
1105#ifdef CONFIG_CGROUPS
1106void sock_update_classid(struct sock *sk)
1107{
1108	u32 classid;
1109
1110	rcu_read_lock();  /* doing current task, which cannot vanish. */
1111	classid = task_cls_classid(current);
1112	rcu_read_unlock();
1113	if (classid && classid != sk->sk_classid)
1114		sk->sk_classid = classid;
1115}
1116EXPORT_SYMBOL(sock_update_classid);
 
 
 
 
 
 
 
 
 
1117#endif
1118
1119/**
1120 *	sk_alloc - All socket objects are allocated here
1121 *	@net: the applicable net namespace
1122 *	@family: protocol family
1123 *	@priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1124 *	@prot: struct proto associated with this new sock instance
1125 */
1126struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
1127		      struct proto *prot)
1128{
1129	struct sock *sk;
1130
1131	sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
1132	if (sk) {
1133		sk->sk_family = family;
1134		/*
1135		 * See comment in struct sock definition to understand
1136		 * why we need sk_prot_creator -acme
1137		 */
1138		sk->sk_prot = sk->sk_prot_creator = prot;
1139		sock_lock_init(sk);
1140		sock_net_set(sk, get_net(net));
1141		atomic_set(&sk->sk_wmem_alloc, 1);
1142
1143		sock_update_classid(sk);
 
1144	}
1145
1146	return sk;
1147}
1148EXPORT_SYMBOL(sk_alloc);
1149
1150static void __sk_free(struct sock *sk)
1151{
1152	struct sk_filter *filter;
1153
1154	if (sk->sk_destruct)
1155		sk->sk_destruct(sk);
1156
1157	filter = rcu_dereference_check(sk->sk_filter,
1158				       atomic_read(&sk->sk_wmem_alloc) == 0);
1159	if (filter) {
1160		sk_filter_uncharge(sk, filter);
1161		rcu_assign_pointer(sk->sk_filter, NULL);
1162	}
1163
1164	sock_disable_timestamp(sk, SOCK_TIMESTAMP);
1165	sock_disable_timestamp(sk, SOCK_TIMESTAMPING_RX_SOFTWARE);
1166
1167	if (atomic_read(&sk->sk_omem_alloc))
1168		printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
1169		       __func__, atomic_read(&sk->sk_omem_alloc));
1170
1171	if (sk->sk_peer_cred)
1172		put_cred(sk->sk_peer_cred);
1173	put_pid(sk->sk_peer_pid);
1174	put_net(sock_net(sk));
1175	sk_prot_free(sk->sk_prot_creator, sk);
1176}
1177
1178void sk_free(struct sock *sk)
1179{
1180	/*
1181	 * We subtract one from sk_wmem_alloc and can know if
1182	 * some packets are still in some tx queue.
1183	 * If not null, sock_wfree() will call __sk_free(sk) later
1184	 */
1185	if (atomic_dec_and_test(&sk->sk_wmem_alloc))
1186		__sk_free(sk);
1187}
1188EXPORT_SYMBOL(sk_free);
1189
1190/*
1191 * Last sock_put should drop reference to sk->sk_net. It has already
1192 * been dropped in sk_change_net. Taking reference to stopping namespace
1193 * is not an option.
1194 * Take reference to a socket to remove it from hash _alive_ and after that
1195 * destroy it in the context of init_net.
1196 */
1197void sk_release_kernel(struct sock *sk)
1198{
1199	if (sk == NULL || sk->sk_socket == NULL)
1200		return;
1201
1202	sock_hold(sk);
1203	sock_release(sk->sk_socket);
1204	release_net(sock_net(sk));
1205	sock_net_set(sk, get_net(&init_net));
1206	sock_put(sk);
1207}
1208EXPORT_SYMBOL(sk_release_kernel);
1209
1210struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
 
 
 
 
 
 
 
 
 
 
 
 
 
1211{
1212	struct sock *newsk;
1213
1214	newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
1215	if (newsk != NULL) {
1216		struct sk_filter *filter;
1217
1218		sock_copy(newsk, sk);
1219
1220		/* SANITY */
1221		get_net(sock_net(newsk));
1222		sk_node_init(&newsk->sk_node);
1223		sock_lock_init(newsk);
1224		bh_lock_sock(newsk);
1225		newsk->sk_backlog.head	= newsk->sk_backlog.tail = NULL;
1226		newsk->sk_backlog.len = 0;
1227
1228		atomic_set(&newsk->sk_rmem_alloc, 0);
1229		/*
1230		 * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1231		 */
1232		atomic_set(&newsk->sk_wmem_alloc, 1);
1233		atomic_set(&newsk->sk_omem_alloc, 0);
1234		skb_queue_head_init(&newsk->sk_receive_queue);
1235		skb_queue_head_init(&newsk->sk_write_queue);
1236#ifdef CONFIG_NET_DMA
1237		skb_queue_head_init(&newsk->sk_async_wait_queue);
1238#endif
1239
1240		spin_lock_init(&newsk->sk_dst_lock);
1241		rwlock_init(&newsk->sk_callback_lock);
1242		lockdep_set_class_and_name(&newsk->sk_callback_lock,
1243				af_callback_keys + newsk->sk_family,
1244				af_family_clock_key_strings[newsk->sk_family]);
1245
1246		newsk->sk_dst_cache	= NULL;
1247		newsk->sk_wmem_queued	= 0;
1248		newsk->sk_forward_alloc = 0;
1249		newsk->sk_send_head	= NULL;
1250		newsk->sk_userlocks	= sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1251
1252		sock_reset_flag(newsk, SOCK_DONE);
1253		skb_queue_head_init(&newsk->sk_error_queue);
1254
1255		filter = rcu_dereference_protected(newsk->sk_filter, 1);
1256		if (filter != NULL)
1257			sk_filter_charge(newsk, filter);
1258
1259		if (unlikely(xfrm_sk_clone_policy(newsk))) {
1260			/* It is still raw copy of parent, so invalidate
1261			 * destructor and make plain sk_free() */
1262			newsk->sk_destruct = NULL;
 
1263			sk_free(newsk);
1264			newsk = NULL;
1265			goto out;
1266		}
1267
1268		newsk->sk_err	   = 0;
1269		newsk->sk_priority = 0;
1270		/*
1271		 * Before updating sk_refcnt, we must commit prior changes to memory
1272		 * (Documentation/RCU/rculist_nulls.txt for details)
1273		 */
1274		smp_wmb();
1275		atomic_set(&newsk->sk_refcnt, 2);
1276
1277		/*
1278		 * Increment the counter in the same struct proto as the master
1279		 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1280		 * is the same as sk->sk_prot->socks, as this field was copied
1281		 * with memcpy).
1282		 *
1283		 * This _changes_ the previous behaviour, where
1284		 * tcp_create_openreq_child always was incrementing the
1285		 * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1286		 * to be taken into account in all callers. -acme
1287		 */
1288		sk_refcnt_debug_inc(newsk);
1289		sk_set_socket(newsk, NULL);
1290		newsk->sk_wq = NULL;
1291
 
 
1292		if (newsk->sk_prot->sockets_allocated)
1293			percpu_counter_inc(newsk->sk_prot->sockets_allocated);
1294
1295		if (sock_flag(newsk, SOCK_TIMESTAMP) ||
1296		    sock_flag(newsk, SOCK_TIMESTAMPING_RX_SOFTWARE))
1297			net_enable_timestamp();
1298	}
1299out:
1300	return newsk;
1301}
1302EXPORT_SYMBOL_GPL(sk_clone);
1303
1304void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1305{
1306	__sk_dst_set(sk, dst);
1307	sk->sk_route_caps = dst->dev->features;
1308	if (sk->sk_route_caps & NETIF_F_GSO)
1309		sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1310	sk->sk_route_caps &= ~sk->sk_route_nocaps;
1311	if (sk_can_gso(sk)) {
1312		if (dst->header_len) {
1313			sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1314		} else {
1315			sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1316			sk->sk_gso_max_size = dst->dev->gso_max_size;
 
1317		}
1318	}
1319}
1320EXPORT_SYMBOL_GPL(sk_setup_caps);
1321
1322void __init sk_init(void)
1323{
1324	if (totalram_pages <= 4096) {
1325		sysctl_wmem_max = 32767;
1326		sysctl_rmem_max = 32767;
1327		sysctl_wmem_default = 32767;
1328		sysctl_rmem_default = 32767;
1329	} else if (totalram_pages >= 131072) {
1330		sysctl_wmem_max = 131071;
1331		sysctl_rmem_max = 131071;
1332	}
1333}
1334
1335/*
1336 *	Simple resource managers for sockets.
1337 */
1338
1339
1340/*
1341 * Write buffer destructor automatically called from kfree_skb.
1342 */
1343void sock_wfree(struct sk_buff *skb)
1344{
1345	struct sock *sk = skb->sk;
1346	unsigned int len = skb->truesize;
1347
1348	if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
1349		/*
1350		 * Keep a reference on sk_wmem_alloc, this will be released
1351		 * after sk_write_space() call
1352		 */
1353		atomic_sub(len - 1, &sk->sk_wmem_alloc);
1354		sk->sk_write_space(sk);
1355		len = 1;
1356	}
1357	/*
1358	 * if sk_wmem_alloc reaches 0, we must finish what sk_free()
1359	 * could not do because of in-flight packets
1360	 */
1361	if (atomic_sub_and_test(len, &sk->sk_wmem_alloc))
1362		__sk_free(sk);
1363}
1364EXPORT_SYMBOL(sock_wfree);
1365
1366/*
1367 * Read buffer destructor automatically called from kfree_skb.
1368 */
1369void sock_rfree(struct sk_buff *skb)
1370{
1371	struct sock *sk = skb->sk;
1372	unsigned int len = skb->truesize;
1373
1374	atomic_sub(len, &sk->sk_rmem_alloc);
1375	sk_mem_uncharge(sk, len);
1376}
1377EXPORT_SYMBOL(sock_rfree);
1378
1379
1380int sock_i_uid(struct sock *sk)
1381{
1382	int uid;
1383
1384	read_lock_bh(&sk->sk_callback_lock);
1385	uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1386	read_unlock_bh(&sk->sk_callback_lock);
1387	return uid;
1388}
1389EXPORT_SYMBOL(sock_i_uid);
1390
1391unsigned long sock_i_ino(struct sock *sk)
1392{
1393	unsigned long ino;
1394
1395	read_lock_bh(&sk->sk_callback_lock);
1396	ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1397	read_unlock_bh(&sk->sk_callback_lock);
1398	return ino;
1399}
1400EXPORT_SYMBOL(sock_i_ino);
1401
1402/*
1403 * Allocate a skb from the socket's send buffer.
1404 */
1405struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1406			     gfp_t priority)
1407{
1408	if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1409		struct sk_buff *skb = alloc_skb(size, priority);
1410		if (skb) {
1411			skb_set_owner_w(skb, sk);
1412			return skb;
1413		}
1414	}
1415	return NULL;
1416}
1417EXPORT_SYMBOL(sock_wmalloc);
1418
1419/*
1420 * Allocate a skb from the socket's receive buffer.
1421 */
1422struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
1423			     gfp_t priority)
1424{
1425	if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
1426		struct sk_buff *skb = alloc_skb(size, priority);
1427		if (skb) {
1428			skb_set_owner_r(skb, sk);
1429			return skb;
1430		}
1431	}
1432	return NULL;
1433}
1434
1435/*
1436 * Allocate a memory block from the socket's option memory buffer.
1437 */
1438void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1439{
1440	if ((unsigned)size <= sysctl_optmem_max &&
1441	    atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1442		void *mem;
1443		/* First do the add, to avoid the race if kmalloc
1444		 * might sleep.
1445		 */
1446		atomic_add(size, &sk->sk_omem_alloc);
1447		mem = kmalloc(size, priority);
1448		if (mem)
1449			return mem;
1450		atomic_sub(size, &sk->sk_omem_alloc);
1451	}
1452	return NULL;
1453}
1454EXPORT_SYMBOL(sock_kmalloc);
1455
1456/*
1457 * Free an option memory block.
1458 */
1459void sock_kfree_s(struct sock *sk, void *mem, int size)
1460{
1461	kfree(mem);
1462	atomic_sub(size, &sk->sk_omem_alloc);
1463}
1464EXPORT_SYMBOL(sock_kfree_s);
1465
1466/* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1467   I think, these locks should be removed for datagram sockets.
1468 */
1469static long sock_wait_for_wmem(struct sock *sk, long timeo)
1470{
1471	DEFINE_WAIT(wait);
1472
1473	clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1474	for (;;) {
1475		if (!timeo)
1476			break;
1477		if (signal_pending(current))
1478			break;
1479		set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1480		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1481		if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1482			break;
1483		if (sk->sk_shutdown & SEND_SHUTDOWN)
1484			break;
1485		if (sk->sk_err)
1486			break;
1487		timeo = schedule_timeout(timeo);
1488	}
1489	finish_wait(sk_sleep(sk), &wait);
1490	return timeo;
1491}
1492
1493
1494/*
1495 *	Generic send/receive buffer handlers
1496 */
1497
1498struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1499				     unsigned long data_len, int noblock,
1500				     int *errcode)
1501{
1502	struct sk_buff *skb;
1503	gfp_t gfp_mask;
1504	long timeo;
1505	int err;
 
 
 
 
 
1506
1507	gfp_mask = sk->sk_allocation;
1508	if (gfp_mask & __GFP_WAIT)
1509		gfp_mask |= __GFP_REPEAT;
1510
1511	timeo = sock_sndtimeo(sk, noblock);
1512	while (1) {
1513		err = sock_error(sk);
1514		if (err != 0)
1515			goto failure;
1516
1517		err = -EPIPE;
1518		if (sk->sk_shutdown & SEND_SHUTDOWN)
1519			goto failure;
1520
1521		if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1522			skb = alloc_skb(header_len, gfp_mask);
1523			if (skb) {
1524				int npages;
1525				int i;
1526
1527				/* No pages, we're done... */
1528				if (!data_len)
1529					break;
1530
1531				npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1532				skb->truesize += data_len;
1533				skb_shinfo(skb)->nr_frags = npages;
1534				for (i = 0; i < npages; i++) {
1535					struct page *page;
1536					skb_frag_t *frag;
1537
1538					page = alloc_pages(sk->sk_allocation, 0);
1539					if (!page) {
1540						err = -ENOBUFS;
1541						skb_shinfo(skb)->nr_frags = i;
1542						kfree_skb(skb);
1543						goto failure;
1544					}
1545
1546					frag = &skb_shinfo(skb)->frags[i];
1547					frag->page = page;
1548					frag->page_offset = 0;
1549					frag->size = (data_len >= PAGE_SIZE ?
1550						      PAGE_SIZE :
1551						      data_len);
1552					data_len -= PAGE_SIZE;
1553				}
1554
1555				/* Full success... */
1556				break;
1557			}
1558			err = -ENOBUFS;
1559			goto failure;
1560		}
1561		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1562		set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1563		err = -EAGAIN;
1564		if (!timeo)
1565			goto failure;
1566		if (signal_pending(current))
1567			goto interrupted;
1568		timeo = sock_wait_for_wmem(sk, timeo);
1569	}
1570
1571	skb_set_owner_w(skb, sk);
1572	return skb;
1573
1574interrupted:
1575	err = sock_intr_errno(timeo);
1576failure:
1577	*errcode = err;
1578	return NULL;
1579}
1580EXPORT_SYMBOL(sock_alloc_send_pskb);
1581
1582struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1583				    int noblock, int *errcode)
1584{
1585	return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1586}
1587EXPORT_SYMBOL(sock_alloc_send_skb);
1588
1589static void __lock_sock(struct sock *sk)
1590	__releases(&sk->sk_lock.slock)
1591	__acquires(&sk->sk_lock.slock)
1592{
1593	DEFINE_WAIT(wait);
1594
1595	for (;;) {
1596		prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1597					TASK_UNINTERRUPTIBLE);
1598		spin_unlock_bh(&sk->sk_lock.slock);
1599		schedule();
1600		spin_lock_bh(&sk->sk_lock.slock);
1601		if (!sock_owned_by_user(sk))
1602			break;
1603	}
1604	finish_wait(&sk->sk_lock.wq, &wait);
1605}
1606
1607static void __release_sock(struct sock *sk)
1608	__releases(&sk->sk_lock.slock)
1609	__acquires(&sk->sk_lock.slock)
1610{
1611	struct sk_buff *skb = sk->sk_backlog.head;
1612
1613	do {
1614		sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1615		bh_unlock_sock(sk);
1616
1617		do {
1618			struct sk_buff *next = skb->next;
1619
 
1620			WARN_ON_ONCE(skb_dst_is_noref(skb));
1621			skb->next = NULL;
1622			sk_backlog_rcv(sk, skb);
1623
1624			/*
1625			 * We are in process context here with softirqs
1626			 * disabled, use cond_resched_softirq() to preempt.
1627			 * This is safe to do because we've taken the backlog
1628			 * queue private:
1629			 */
1630			cond_resched_softirq();
1631
1632			skb = next;
1633		} while (skb != NULL);
1634
1635		bh_lock_sock(sk);
1636	} while ((skb = sk->sk_backlog.head) != NULL);
1637
1638	/*
1639	 * Doing the zeroing here guarantee we can not loop forever
1640	 * while a wild producer attempts to flood us.
1641	 */
1642	sk->sk_backlog.len = 0;
1643}
1644
1645/**
1646 * sk_wait_data - wait for data to arrive at sk_receive_queue
1647 * @sk:    sock to wait on
1648 * @timeo: for how long
1649 *
1650 * Now socket state including sk->sk_err is changed only under lock,
1651 * hence we may omit checks after joining wait queue.
1652 * We check receive queue before schedule() only as optimization;
1653 * it is very likely that release_sock() added new data.
1654 */
1655int sk_wait_data(struct sock *sk, long *timeo)
1656{
1657	int rc;
1658	DEFINE_WAIT(wait);
1659
1660	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1661	set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1662	rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1663	clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1664	finish_wait(sk_sleep(sk), &wait);
1665	return rc;
1666}
1667EXPORT_SYMBOL(sk_wait_data);
1668
1669/**
1670 *	__sk_mem_schedule - increase sk_forward_alloc and memory_allocated
1671 *	@sk: socket
1672 *	@size: memory size to allocate
1673 *	@kind: allocation type
1674 *
1675 *	If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
1676 *	rmem allocation. This function assumes that protocols which have
1677 *	memory_pressure use sk_wmem_queued as write buffer accounting.
1678 */
1679int __sk_mem_schedule(struct sock *sk, int size, int kind)
1680{
1681	struct proto *prot = sk->sk_prot;
1682	int amt = sk_mem_pages(size);
1683	long allocated;
 
1684
1685	sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
1686	allocated = atomic_long_add_return(amt, prot->memory_allocated);
 
1687
1688	/* Under limit. */
1689	if (allocated <= prot->sysctl_mem[0]) {
1690		if (prot->memory_pressure && *prot->memory_pressure)
1691			*prot->memory_pressure = 0;
1692		return 1;
1693	}
1694
1695	/* Under pressure. */
1696	if (allocated > prot->sysctl_mem[1])
1697		if (prot->enter_memory_pressure)
1698			prot->enter_memory_pressure(sk);
1699
1700	/* Over hard limit. */
1701	if (allocated > prot->sysctl_mem[2])
 
1702		goto suppress_allocation;
1703
1704	/* guarantee minimum buffer size under pressure */
1705	if (kind == SK_MEM_RECV) {
1706		if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
1707			return 1;
 
1708	} else { /* SK_MEM_SEND */
1709		if (sk->sk_type == SOCK_STREAM) {
1710			if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
1711				return 1;
1712		} else if (atomic_read(&sk->sk_wmem_alloc) <
1713			   prot->sysctl_wmem[0])
1714				return 1;
1715	}
1716
1717	if (prot->memory_pressure) {
1718		int alloc;
1719
1720		if (!*prot->memory_pressure)
1721			return 1;
1722		alloc = percpu_counter_read_positive(prot->sockets_allocated);
1723		if (prot->sysctl_mem[2] > alloc *
1724		    sk_mem_pages(sk->sk_wmem_queued +
1725				 atomic_read(&sk->sk_rmem_alloc) +
1726				 sk->sk_forward_alloc))
1727			return 1;
1728	}
1729
1730suppress_allocation:
1731
1732	if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
1733		sk_stream_moderate_sndbuf(sk);
1734
1735		/* Fail only if socket is _under_ its sndbuf.
1736		 * In this case we cannot block, so that we have to fail.
1737		 */
1738		if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
1739			return 1;
1740	}
1741
1742	trace_sock_exceed_buf_limit(sk, prot, allocated);
1743
1744	/* Alas. Undo changes. */
1745	sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
1746	atomic_long_sub(amt, prot->memory_allocated);
 
 
1747	return 0;
1748}
1749EXPORT_SYMBOL(__sk_mem_schedule);
1750
1751/**
1752 *	__sk_reclaim - reclaim memory_allocated
1753 *	@sk: socket
1754 */
1755void __sk_mem_reclaim(struct sock *sk)
1756{
1757	struct proto *prot = sk->sk_prot;
1758
1759	atomic_long_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,
1760		   prot->memory_allocated);
1761	sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
1762
1763	if (prot->memory_pressure && *prot->memory_pressure &&
1764	    (atomic_long_read(prot->memory_allocated) < prot->sysctl_mem[0]))
1765		*prot->memory_pressure = 0;
1766}
1767EXPORT_SYMBOL(__sk_mem_reclaim);
1768
1769
1770/*
1771 * Set of default routines for initialising struct proto_ops when
1772 * the protocol does not support a particular function. In certain
1773 * cases where it makes no sense for a protocol to have a "do nothing"
1774 * function, some default processing is provided.
1775 */
1776
1777int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1778{
1779	return -EOPNOTSUPP;
1780}
1781EXPORT_SYMBOL(sock_no_bind);
1782
1783int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1784		    int len, int flags)
1785{
1786	return -EOPNOTSUPP;
1787}
1788EXPORT_SYMBOL(sock_no_connect);
1789
1790int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1791{
1792	return -EOPNOTSUPP;
1793}
1794EXPORT_SYMBOL(sock_no_socketpair);
1795
1796int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1797{
1798	return -EOPNOTSUPP;
1799}
1800EXPORT_SYMBOL(sock_no_accept);
1801
1802int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1803		    int *len, int peer)
1804{
1805	return -EOPNOTSUPP;
1806}
1807EXPORT_SYMBOL(sock_no_getname);
1808
1809unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
1810{
1811	return 0;
1812}
1813EXPORT_SYMBOL(sock_no_poll);
1814
1815int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1816{
1817	return -EOPNOTSUPP;
1818}
1819EXPORT_SYMBOL(sock_no_ioctl);
1820
1821int sock_no_listen(struct socket *sock, int backlog)
1822{
1823	return -EOPNOTSUPP;
1824}
1825EXPORT_SYMBOL(sock_no_listen);
1826
1827int sock_no_shutdown(struct socket *sock, int how)
1828{
1829	return -EOPNOTSUPP;
1830}
1831EXPORT_SYMBOL(sock_no_shutdown);
1832
1833int sock_no_setsockopt(struct socket *sock, int level, int optname,
1834		    char __user *optval, unsigned int optlen)
1835{
1836	return -EOPNOTSUPP;
1837}
1838EXPORT_SYMBOL(sock_no_setsockopt);
1839
1840int sock_no_getsockopt(struct socket *sock, int level, int optname,
1841		    char __user *optval, int __user *optlen)
1842{
1843	return -EOPNOTSUPP;
1844}
1845EXPORT_SYMBOL(sock_no_getsockopt);
1846
1847int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1848		    size_t len)
1849{
1850	return -EOPNOTSUPP;
1851}
1852EXPORT_SYMBOL(sock_no_sendmsg);
1853
1854int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1855		    size_t len, int flags)
1856{
1857	return -EOPNOTSUPP;
1858}
1859EXPORT_SYMBOL(sock_no_recvmsg);
1860
1861int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1862{
1863	/* Mirror missing mmap method error code */
1864	return -ENODEV;
1865}
1866EXPORT_SYMBOL(sock_no_mmap);
1867
1868ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1869{
1870	ssize_t res;
1871	struct msghdr msg = {.msg_flags = flags};
1872	struct kvec iov;
1873	char *kaddr = kmap(page);
1874	iov.iov_base = kaddr + offset;
1875	iov.iov_len = size;
1876	res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1877	kunmap(page);
1878	return res;
1879}
1880EXPORT_SYMBOL(sock_no_sendpage);
1881
1882/*
1883 *	Default Socket Callbacks
1884 */
1885
1886static void sock_def_wakeup(struct sock *sk)
1887{
1888	struct socket_wq *wq;
1889
1890	rcu_read_lock();
1891	wq = rcu_dereference(sk->sk_wq);
1892	if (wq_has_sleeper(wq))
1893		wake_up_interruptible_all(&wq->wait);
1894	rcu_read_unlock();
1895}
1896
1897static void sock_def_error_report(struct sock *sk)
1898{
1899	struct socket_wq *wq;
1900
1901	rcu_read_lock();
1902	wq = rcu_dereference(sk->sk_wq);
1903	if (wq_has_sleeper(wq))
1904		wake_up_interruptible_poll(&wq->wait, POLLERR);
1905	sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
1906	rcu_read_unlock();
1907}
1908
1909static void sock_def_readable(struct sock *sk, int len)
1910{
1911	struct socket_wq *wq;
1912
1913	rcu_read_lock();
1914	wq = rcu_dereference(sk->sk_wq);
1915	if (wq_has_sleeper(wq))
1916		wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
1917						POLLRDNORM | POLLRDBAND);
1918	sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
1919	rcu_read_unlock();
1920}
1921
1922static void sock_def_write_space(struct sock *sk)
1923{
1924	struct socket_wq *wq;
1925
1926	rcu_read_lock();
1927
1928	/* Do not wake up a writer until he can make "significant"
1929	 * progress.  --DaveM
1930	 */
1931	if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1932		wq = rcu_dereference(sk->sk_wq);
1933		if (wq_has_sleeper(wq))
1934			wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
1935						POLLWRNORM | POLLWRBAND);
1936
1937		/* Should agree with poll, otherwise some programs break */
1938		if (sock_writeable(sk))
1939			sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
1940	}
1941
1942	rcu_read_unlock();
1943}
1944
1945static void sock_def_destruct(struct sock *sk)
1946{
1947	kfree(sk->sk_protinfo);
1948}
1949
1950void sk_send_sigurg(struct sock *sk)
1951{
1952	if (sk->sk_socket && sk->sk_socket->file)
1953		if (send_sigurg(&sk->sk_socket->file->f_owner))
1954			sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
1955}
1956EXPORT_SYMBOL(sk_send_sigurg);
1957
1958void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1959		    unsigned long expires)
1960{
1961	if (!mod_timer(timer, expires))
1962		sock_hold(sk);
1963}
1964EXPORT_SYMBOL(sk_reset_timer);
1965
1966void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1967{
1968	if (timer_pending(timer) && del_timer(timer))
1969		__sock_put(sk);
1970}
1971EXPORT_SYMBOL(sk_stop_timer);
1972
1973void sock_init_data(struct socket *sock, struct sock *sk)
1974{
1975	skb_queue_head_init(&sk->sk_receive_queue);
1976	skb_queue_head_init(&sk->sk_write_queue);
1977	skb_queue_head_init(&sk->sk_error_queue);
1978#ifdef CONFIG_NET_DMA
1979	skb_queue_head_init(&sk->sk_async_wait_queue);
1980#endif
1981
1982	sk->sk_send_head	=	NULL;
1983
1984	init_timer(&sk->sk_timer);
1985
1986	sk->sk_allocation	=	GFP_KERNEL;
1987	sk->sk_rcvbuf		=	sysctl_rmem_default;
1988	sk->sk_sndbuf		=	sysctl_wmem_default;
1989	sk->sk_state		=	TCP_CLOSE;
1990	sk_set_socket(sk, sock);
1991
1992	sock_set_flag(sk, SOCK_ZAPPED);
1993
1994	if (sock) {
1995		sk->sk_type	=	sock->type;
1996		sk->sk_wq	=	sock->wq;
1997		sock->sk	=	sk;
1998	} else
1999		sk->sk_wq	=	NULL;
2000
2001	spin_lock_init(&sk->sk_dst_lock);
2002	rwlock_init(&sk->sk_callback_lock);
2003	lockdep_set_class_and_name(&sk->sk_callback_lock,
2004			af_callback_keys + sk->sk_family,
2005			af_family_clock_key_strings[sk->sk_family]);
2006
2007	sk->sk_state_change	=	sock_def_wakeup;
2008	sk->sk_data_ready	=	sock_def_readable;
2009	sk->sk_write_space	=	sock_def_write_space;
2010	sk->sk_error_report	=	sock_def_error_report;
2011	sk->sk_destruct		=	sock_def_destruct;
2012
2013	sk->sk_sndmsg_page	=	NULL;
2014	sk->sk_sndmsg_off	=	0;
 
2015
2016	sk->sk_peer_pid 	=	NULL;
2017	sk->sk_peer_cred	=	NULL;
2018	sk->sk_write_pending	=	0;
2019	sk->sk_rcvlowat		=	1;
2020	sk->sk_rcvtimeo		=	MAX_SCHEDULE_TIMEOUT;
2021	sk->sk_sndtimeo		=	MAX_SCHEDULE_TIMEOUT;
2022
2023	sk->sk_stamp = ktime_set(-1L, 0);
2024
2025	/*
2026	 * Before updating sk_refcnt, we must commit prior changes to memory
2027	 * (Documentation/RCU/rculist_nulls.txt for details)
2028	 */
2029	smp_wmb();
2030	atomic_set(&sk->sk_refcnt, 1);
2031	atomic_set(&sk->sk_drops, 0);
2032}
2033EXPORT_SYMBOL(sock_init_data);
2034
2035void lock_sock_nested(struct sock *sk, int subclass)
2036{
2037	might_sleep();
2038	spin_lock_bh(&sk->sk_lock.slock);
2039	if (sk->sk_lock.owned)
2040		__lock_sock(sk);
2041	sk->sk_lock.owned = 1;
2042	spin_unlock(&sk->sk_lock.slock);
2043	/*
2044	 * The sk_lock has mutex_lock() semantics here:
2045	 */
2046	mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
2047	local_bh_enable();
2048}
2049EXPORT_SYMBOL(lock_sock_nested);
2050
2051void release_sock(struct sock *sk)
2052{
2053	/*
2054	 * The sk_lock has mutex_unlock() semantics:
2055	 */
2056	mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
2057
2058	spin_lock_bh(&sk->sk_lock.slock);
2059	if (sk->sk_backlog.tail)
2060		__release_sock(sk);
2061	sk->sk_lock.owned = 0;
2062	if (waitqueue_active(&sk->sk_lock.wq))
2063		wake_up(&sk->sk_lock.wq);
2064	spin_unlock_bh(&sk->sk_lock.slock);
2065}
2066EXPORT_SYMBOL(release_sock);
2067
2068/**
2069 * lock_sock_fast - fast version of lock_sock
2070 * @sk: socket
2071 *
2072 * This version should be used for very small section, where process wont block
2073 * return false if fast path is taken
2074 *   sk_lock.slock locked, owned = 0, BH disabled
2075 * return true if slow path is taken
2076 *   sk_lock.slock unlocked, owned = 1, BH enabled
2077 */
2078bool lock_sock_fast(struct sock *sk)
2079{
2080	might_sleep();
2081	spin_lock_bh(&sk->sk_lock.slock);
2082
2083	if (!sk->sk_lock.owned)
2084		/*
2085		 * Note : We must disable BH
2086		 */
2087		return false;
2088
2089	__lock_sock(sk);
2090	sk->sk_lock.owned = 1;
2091	spin_unlock(&sk->sk_lock.slock);
2092	/*
2093	 * The sk_lock has mutex_lock() semantics here:
2094	 */
2095	mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
2096	local_bh_enable();
2097	return true;
2098}
2099EXPORT_SYMBOL(lock_sock_fast);
2100
2101int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
2102{
2103	struct timeval tv;
2104	if (!sock_flag(sk, SOCK_TIMESTAMP))
2105		sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2106	tv = ktime_to_timeval(sk->sk_stamp);
2107	if (tv.tv_sec == -1)
2108		return -ENOENT;
2109	if (tv.tv_sec == 0) {
2110		sk->sk_stamp = ktime_get_real();
2111		tv = ktime_to_timeval(sk->sk_stamp);
2112	}
2113	return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
2114}
2115EXPORT_SYMBOL(sock_get_timestamp);
2116
2117int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
2118{
2119	struct timespec ts;
2120	if (!sock_flag(sk, SOCK_TIMESTAMP))
2121		sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2122	ts = ktime_to_timespec(sk->sk_stamp);
2123	if (ts.tv_sec == -1)
2124		return -ENOENT;
2125	if (ts.tv_sec == 0) {
2126		sk->sk_stamp = ktime_get_real();
2127		ts = ktime_to_timespec(sk->sk_stamp);
2128	}
2129	return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
2130}
2131EXPORT_SYMBOL(sock_get_timestampns);
2132
2133void sock_enable_timestamp(struct sock *sk, int flag)
2134{
2135	if (!sock_flag(sk, flag)) {
 
 
2136		sock_set_flag(sk, flag);
2137		/*
2138		 * we just set one of the two flags which require net
2139		 * time stamping, but time stamping might have been on
2140		 * already because of the other one
2141		 */
2142		if (!sock_flag(sk,
2143				flag == SOCK_TIMESTAMP ?
2144				SOCK_TIMESTAMPING_RX_SOFTWARE :
2145				SOCK_TIMESTAMP))
2146			net_enable_timestamp();
2147	}
2148}
2149
2150/*
2151 *	Get a socket option on an socket.
2152 *
2153 *	FIX: POSIX 1003.1g is very ambiguous here. It states that
2154 *	asynchronous errors should be reported by getsockopt. We assume
2155 *	this means if you specify SO_ERROR (otherwise whats the point of it).
2156 */
2157int sock_common_getsockopt(struct socket *sock, int level, int optname,
2158			   char __user *optval, int __user *optlen)
2159{
2160	struct sock *sk = sock->sk;
2161
2162	return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2163}
2164EXPORT_SYMBOL(sock_common_getsockopt);
2165
2166#ifdef CONFIG_COMPAT
2167int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
2168				  char __user *optval, int __user *optlen)
2169{
2170	struct sock *sk = sock->sk;
2171
2172	if (sk->sk_prot->compat_getsockopt != NULL)
2173		return sk->sk_prot->compat_getsockopt(sk, level, optname,
2174						      optval, optlen);
2175	return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2176}
2177EXPORT_SYMBOL(compat_sock_common_getsockopt);
2178#endif
2179
2180int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
2181			struct msghdr *msg, size_t size, int flags)
2182{
2183	struct sock *sk = sock->sk;
2184	int addr_len = 0;
2185	int err;
2186
2187	err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
2188				   flags & ~MSG_DONTWAIT, &addr_len);
2189	if (err >= 0)
2190		msg->msg_namelen = addr_len;
2191	return err;
2192}
2193EXPORT_SYMBOL(sock_common_recvmsg);
2194
2195/*
2196 *	Set socket options on an inet socket.
2197 */
2198int sock_common_setsockopt(struct socket *sock, int level, int optname,
2199			   char __user *optval, unsigned int optlen)
2200{
2201	struct sock *sk = sock->sk;
2202
2203	return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2204}
2205EXPORT_SYMBOL(sock_common_setsockopt);
2206
2207#ifdef CONFIG_COMPAT
2208int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
2209				  char __user *optval, unsigned int optlen)
2210{
2211	struct sock *sk = sock->sk;
2212
2213	if (sk->sk_prot->compat_setsockopt != NULL)
2214		return sk->sk_prot->compat_setsockopt(sk, level, optname,
2215						      optval, optlen);
2216	return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2217}
2218EXPORT_SYMBOL(compat_sock_common_setsockopt);
2219#endif
2220
2221void sk_common_release(struct sock *sk)
2222{
2223	if (sk->sk_prot->destroy)
2224		sk->sk_prot->destroy(sk);
2225
2226	/*
2227	 * Observation: when sock_common_release is called, processes have
2228	 * no access to socket. But net still has.
2229	 * Step one, detach it from networking:
2230	 *
2231	 * A. Remove from hash tables.
2232	 */
2233
2234	sk->sk_prot->unhash(sk);
2235
2236	/*
2237	 * In this point socket cannot receive new packets, but it is possible
2238	 * that some packets are in flight because some CPU runs receiver and
2239	 * did hash table lookup before we unhashed socket. They will achieve
2240	 * receive queue and will be purged by socket destructor.
2241	 *
2242	 * Also we still have packets pending on receive queue and probably,
2243	 * our own packets waiting in device queues. sock_destroy will drain
2244	 * receive queue, but transmitted packets will delay socket destruction
2245	 * until the last reference will be released.
2246	 */
2247
2248	sock_orphan(sk);
2249
2250	xfrm_sk_free_policy(sk);
2251
2252	sk_refcnt_debug_release(sk);
2253	sock_put(sk);
2254}
2255EXPORT_SYMBOL(sk_common_release);
2256
2257static DEFINE_RWLOCK(proto_list_lock);
2258static LIST_HEAD(proto_list);
2259
2260#ifdef CONFIG_PROC_FS
2261#define PROTO_INUSE_NR	64	/* should be enough for the first time */
2262struct prot_inuse {
2263	int val[PROTO_INUSE_NR];
2264};
2265
2266static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
2267
2268#ifdef CONFIG_NET_NS
2269void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2270{
2271	__this_cpu_add(net->core.inuse->val[prot->inuse_idx], val);
2272}
2273EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2274
2275int sock_prot_inuse_get(struct net *net, struct proto *prot)
2276{
2277	int cpu, idx = prot->inuse_idx;
2278	int res = 0;
2279
2280	for_each_possible_cpu(cpu)
2281		res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
2282
2283	return res >= 0 ? res : 0;
2284}
2285EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2286
2287static int __net_init sock_inuse_init_net(struct net *net)
2288{
2289	net->core.inuse = alloc_percpu(struct prot_inuse);
2290	return net->core.inuse ? 0 : -ENOMEM;
2291}
2292
2293static void __net_exit sock_inuse_exit_net(struct net *net)
2294{
2295	free_percpu(net->core.inuse);
2296}
2297
2298static struct pernet_operations net_inuse_ops = {
2299	.init = sock_inuse_init_net,
2300	.exit = sock_inuse_exit_net,
2301};
2302
2303static __init int net_inuse_init(void)
2304{
2305	if (register_pernet_subsys(&net_inuse_ops))
2306		panic("Cannot initialize net inuse counters");
2307
2308	return 0;
2309}
2310
2311core_initcall(net_inuse_init);
2312#else
2313static DEFINE_PER_CPU(struct prot_inuse, prot_inuse);
2314
2315void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2316{
2317	__this_cpu_add(prot_inuse.val[prot->inuse_idx], val);
2318}
2319EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2320
2321int sock_prot_inuse_get(struct net *net, struct proto *prot)
2322{
2323	int cpu, idx = prot->inuse_idx;
2324	int res = 0;
2325
2326	for_each_possible_cpu(cpu)
2327		res += per_cpu(prot_inuse, cpu).val[idx];
2328
2329	return res >= 0 ? res : 0;
2330}
2331EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2332#endif
2333
2334static void assign_proto_idx(struct proto *prot)
2335{
2336	prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
2337
2338	if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
2339		printk(KERN_ERR "PROTO_INUSE_NR exhausted\n");
2340		return;
2341	}
2342
2343	set_bit(prot->inuse_idx, proto_inuse_idx);
2344}
2345
2346static void release_proto_idx(struct proto *prot)
2347{
2348	if (prot->inuse_idx != PROTO_INUSE_NR - 1)
2349		clear_bit(prot->inuse_idx, proto_inuse_idx);
2350}
2351#else
2352static inline void assign_proto_idx(struct proto *prot)
2353{
2354}
2355
2356static inline void release_proto_idx(struct proto *prot)
2357{
2358}
2359#endif
2360
2361int proto_register(struct proto *prot, int alloc_slab)
2362{
2363	if (alloc_slab) {
2364		prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
2365					SLAB_HWCACHE_ALIGN | prot->slab_flags,
2366					NULL);
2367
2368		if (prot->slab == NULL) {
2369			printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
2370			       prot->name);
2371			goto out;
2372		}
2373
2374		if (prot->rsk_prot != NULL) {
2375			prot->rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s", prot->name);
2376			if (prot->rsk_prot->slab_name == NULL)
2377				goto out_free_sock_slab;
2378
2379			prot->rsk_prot->slab = kmem_cache_create(prot->rsk_prot->slab_name,
2380								 prot->rsk_prot->obj_size, 0,
2381								 SLAB_HWCACHE_ALIGN, NULL);
2382
2383			if (prot->rsk_prot->slab == NULL) {
2384				printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
2385				       prot->name);
2386				goto out_free_request_sock_slab_name;
2387			}
2388		}
2389
2390		if (prot->twsk_prot != NULL) {
2391			prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
2392
2393			if (prot->twsk_prot->twsk_slab_name == NULL)
2394				goto out_free_request_sock_slab;
2395
2396			prot->twsk_prot->twsk_slab =
2397				kmem_cache_create(prot->twsk_prot->twsk_slab_name,
2398						  prot->twsk_prot->twsk_obj_size,
2399						  0,
2400						  SLAB_HWCACHE_ALIGN |
2401							prot->slab_flags,
2402						  NULL);
2403			if (prot->twsk_prot->twsk_slab == NULL)
2404				goto out_free_timewait_sock_slab_name;
2405		}
2406	}
2407
2408	write_lock(&proto_list_lock);
2409	list_add(&prot->node, &proto_list);
2410	assign_proto_idx(prot);
2411	write_unlock(&proto_list_lock);
2412	return 0;
2413
2414out_free_timewait_sock_slab_name:
2415	kfree(prot->twsk_prot->twsk_slab_name);
2416out_free_request_sock_slab:
2417	if (prot->rsk_prot && prot->rsk_prot->slab) {
2418		kmem_cache_destroy(prot->rsk_prot->slab);
2419		prot->rsk_prot->slab = NULL;
2420	}
2421out_free_request_sock_slab_name:
2422	if (prot->rsk_prot)
2423		kfree(prot->rsk_prot->slab_name);
2424out_free_sock_slab:
2425	kmem_cache_destroy(prot->slab);
2426	prot->slab = NULL;
2427out:
2428	return -ENOBUFS;
2429}
2430EXPORT_SYMBOL(proto_register);
2431
2432void proto_unregister(struct proto *prot)
2433{
2434	write_lock(&proto_list_lock);
2435	release_proto_idx(prot);
2436	list_del(&prot->node);
2437	write_unlock(&proto_list_lock);
2438
2439	if (prot->slab != NULL) {
2440		kmem_cache_destroy(prot->slab);
2441		prot->slab = NULL;
2442	}
2443
2444	if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
2445		kmem_cache_destroy(prot->rsk_prot->slab);
2446		kfree(prot->rsk_prot->slab_name);
2447		prot->rsk_prot->slab = NULL;
2448	}
2449
2450	if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
2451		kmem_cache_destroy(prot->twsk_prot->twsk_slab);
2452		kfree(prot->twsk_prot->twsk_slab_name);
2453		prot->twsk_prot->twsk_slab = NULL;
2454	}
2455}
2456EXPORT_SYMBOL(proto_unregister);
2457
2458#ifdef CONFIG_PROC_FS
2459static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
2460	__acquires(proto_list_lock)
2461{
2462	read_lock(&proto_list_lock);
2463	return seq_list_start_head(&proto_list, *pos);
2464}
2465
2466static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2467{
2468	return seq_list_next(v, &proto_list, pos);
2469}
2470
2471static void proto_seq_stop(struct seq_file *seq, void *v)
2472	__releases(proto_list_lock)
2473{
2474	read_unlock(&proto_list_lock);
2475}
2476
2477static char proto_method_implemented(const void *method)
2478{
2479	return method == NULL ? 'n' : 'y';
2480}
 
 
 
 
 
 
 
 
 
 
2481
2482static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
2483{
 
2484	seq_printf(seq, "%-9s %4u %6d  %6ld   %-3s %6u   %-3s  %-10s "
2485			"%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
2486		   proto->name,
2487		   proto->obj_size,
2488		   sock_prot_inuse_get(seq_file_net(seq), proto),
2489		   proto->memory_allocated != NULL ? atomic_long_read(proto->memory_allocated) : -1L,
2490		   proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
2491		   proto->max_header,
2492		   proto->slab == NULL ? "no" : "yes",
2493		   module_name(proto->owner),
2494		   proto_method_implemented(proto->close),
2495		   proto_method_implemented(proto->connect),
2496		   proto_method_implemented(proto->disconnect),
2497		   proto_method_implemented(proto->accept),
2498		   proto_method_implemented(proto->ioctl),
2499		   proto_method_implemented(proto->init),
2500		   proto_method_implemented(proto->destroy),
2501		   proto_method_implemented(proto->shutdown),
2502		   proto_method_implemented(proto->setsockopt),
2503		   proto_method_implemented(proto->getsockopt),
2504		   proto_method_implemented(proto->sendmsg),
2505		   proto_method_implemented(proto->recvmsg),
2506		   proto_method_implemented(proto->sendpage),
2507		   proto_method_implemented(proto->bind),
2508		   proto_method_implemented(proto->backlog_rcv),
2509		   proto_method_implemented(proto->hash),
2510		   proto_method_implemented(proto->unhash),
2511		   proto_method_implemented(proto->get_port),
2512		   proto_method_implemented(proto->enter_memory_pressure));
2513}
2514
2515static int proto_seq_show(struct seq_file *seq, void *v)
2516{
2517	if (v == &proto_list)
2518		seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
2519			   "protocol",
2520			   "size",
2521			   "sockets",
2522			   "memory",
2523			   "press",
2524			   "maxhdr",
2525			   "slab",
2526			   "module",
2527			   "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
2528	else
2529		proto_seq_printf(seq, list_entry(v, struct proto, node));
2530	return 0;
2531}
2532
2533static const struct seq_operations proto_seq_ops = {
2534	.start  = proto_seq_start,
2535	.next   = proto_seq_next,
2536	.stop   = proto_seq_stop,
2537	.show   = proto_seq_show,
2538};
2539
2540static int proto_seq_open(struct inode *inode, struct file *file)
2541{
2542	return seq_open_net(inode, file, &proto_seq_ops,
2543			    sizeof(struct seq_net_private));
2544}
2545
2546static const struct file_operations proto_seq_fops = {
2547	.owner		= THIS_MODULE,
2548	.open		= proto_seq_open,
2549	.read		= seq_read,
2550	.llseek		= seq_lseek,
2551	.release	= seq_release_net,
2552};
2553
2554static __net_init int proto_init_net(struct net *net)
2555{
2556	if (!proc_net_fops_create(net, "protocols", S_IRUGO, &proto_seq_fops))
2557		return -ENOMEM;
2558
2559	return 0;
2560}
2561
2562static __net_exit void proto_exit_net(struct net *net)
2563{
2564	proc_net_remove(net, "protocols");
2565}
2566
2567
2568static __net_initdata struct pernet_operations proto_net_ops = {
2569	.init = proto_init_net,
2570	.exit = proto_exit_net,
2571};
2572
2573static int __init proto_init(void)
2574{
2575	return register_pernet_subsys(&proto_net_ops);
2576}
2577
2578subsys_initcall(proto_init);
2579
2580#endif /* PROC_FS */