blob: 950409dcec3d5763bf4822c4fb8599e20808c728 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 * Definitions for the AF_INET socket handler.
7 *
8 * Version: @(#)sock.h 1.0.4 05/13/93
9 *
Jesper Juhl02c30a82005-05-05 16:16:16 -070010 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Corey Minyard <wf-rch!minyard@relay.EU.net>
13 * Florian La Roche <flla@stud.uni-sb.de>
14 *
15 * Fixes:
16 * Alan Cox : Volatiles in skbuff pointers. See
17 * skbuff comments. May be overdone,
18 * better to prove they can be removed
19 * than the reverse.
20 * Alan Cox : Added a zapped field for tcp to note
21 * a socket is reset and must stay shut up
22 * Alan Cox : New fields for options
23 * Pauline Middelink : identd support
24 * Alan Cox : Eliminate low level recv/recvfrom
25 * David S. Miller : New socket lookup architecture.
26 * Steve Whitehouse: Default routines for sock_ops
27 * Arnaldo C. Melo : removed net_pinfo, tp_pinfo and made
28 * protinfo be just a void pointer, as the
29 * protocol specific parts were moved to
30 * respective headers and ipv4/v6, etc now
31 * use private slabcaches for its socks
32 * Pedro Hortas : New flags field for socket options
33 *
34 *
35 * This program is free software; you can redistribute it and/or
36 * modify it under the terms of the GNU General Public License
37 * as published by the Free Software Foundation; either version
38 * 2 of the License, or (at your option) any later version.
39 */
40#ifndef _SOCK_H
41#define _SOCK_H
42
Ilpo Järvinen172589c2007-08-28 15:50:33 -070043#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/list.h>
Eric Dumazet88ab1932008-11-16 19:39:21 -080045#include <linux/list_nulls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <linux/timer.h>
47#include <linux/cache.h>
48#include <linux/module.h>
Ingo Molnara5b5bb92006-07-03 00:25:35 -070049#include <linux/lockdep.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/netdevice.h>
51#include <linux/skbuff.h> /* struct sk_buff */
Al Virod7fe0f22006-12-03 23:15:30 -050052#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <linux/security.h>
54
55#include <linux/filter.h>
Eric Dumazet88ab1932008-11-16 19:39:21 -080056#include <linux/rculist_nulls.h>
Jiri Olsaa57de0b2009-07-08 12:09:13 +000057#include <linux/poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59#include <asm/atomic.h>
60#include <net/dst.h>
61#include <net/checksum.h>
62
63/*
64 * This structure really needs to be cleaned up.
65 * Most of it is for TCP, and not used by any of
66 * the other protocols.
67 */
68
69/* Define this to get the SOCK_DBG debugging facility. */
70#define SOCK_DEBUGGING
71#ifdef SOCK_DEBUGGING
72#define SOCK_DEBUG(sk, msg...) do { if ((sk) && sock_flag((sk), SOCK_DBG)) \
73 printk(KERN_DEBUG msg); } while (0)
74#else
Stephen Hemminger4cd90292008-03-21 15:54:53 -070075/* Validate arguments and do nothing */
76static void inline int __attribute__ ((format (printf, 2, 3)))
77SOCK_DEBUG(struct sock *sk, const char *msg, ...)
78{
79}
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#endif
81
82/* This is the per-socket lock. The spinlock provides a synchronization
83 * between user contexts and software interrupt processing, whereas the
84 * mini-semaphore synchronizes multiple users amongst themselves.
85 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070086typedef struct {
87 spinlock_t slock;
John Heffnerd2e91172007-09-12 10:44:19 +020088 int owned;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 wait_queue_head_t wq;
Ingo Molnara5b5bb92006-07-03 00:25:35 -070090 /*
91 * We express the mutex-alike socket_lock semantics
92 * to the lock validator by explicitly managing
93 * the slock as a lock variant (in addition to
94 * the slock itself):
95 */
96#ifdef CONFIG_DEBUG_LOCK_ALLOC
97 struct lockdep_map dep_map;
98#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070099} socket_lock_t;
100
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101struct sock;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700102struct proto;
Denis V. Lunev0eeb8ff2007-12-04 01:15:45 -0800103struct net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105/**
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700106 * struct sock_common - minimal network layer representation of sockets
Eric Dumazet4dc6dc72009-07-15 23:13:10 +0000107 * @skc_node: main hash linkage for various protocol lookup tables
108 * @skc_nulls_node: main hash linkage for UDP/UDP-Lite protocol
109 * @skc_refcnt: reference count
110 * @skc_hash: hash value used with various protocol lookup tables
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700111 * @skc_family: network address family
112 * @skc_state: Connection state
113 * @skc_reuse: %SO_REUSEADDR setting
114 * @skc_bound_dev_if: bound device index if != 0
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700115 * @skc_bind_node: bind hash linkage for various protocol lookup tables
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700116 * @skc_prot: protocol handlers inside a network family
Eric W. Biederman07feaeb2007-09-12 11:58:02 +0200117 * @skc_net: reference to the network namespace of this socket
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700118 *
119 * This is the minimal network layer representation of sockets, the header
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700120 * for struct sock and struct inet_timewait_sock.
121 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122struct sock_common {
Eric Dumazet4dc6dc72009-07-15 23:13:10 +0000123 /*
124 * first fields are not copied in sock_copy()
125 */
Eric Dumazet88ab1932008-11-16 19:39:21 -0800126 union {
127 struct hlist_node skc_node;
128 struct hlist_nulls_node skc_nulls_node;
129 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 atomic_t skc_refcnt;
Eric Dumazet4dc6dc72009-07-15 23:13:10 +0000131
Eric Dumazet81c3d542005-10-03 14:13:38 -0700132 unsigned int skc_hash;
Eric Dumazet4dc6dc72009-07-15 23:13:10 +0000133 unsigned short skc_family;
134 volatile unsigned char skc_state;
135 unsigned char skc_reuse;
136 int skc_bound_dev_if;
137 struct hlist_node skc_bind_node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700138 struct proto *skc_prot;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900139#ifdef CONFIG_NET_NS
Eric W. Biederman07feaeb2007-09-12 11:58:02 +0200140 struct net *skc_net;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900141#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142};
143
144/**
145 * struct sock - network layer representation of sockets
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700146 * @__sk_common: shared layout with inet_timewait_sock
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700147 * @sk_shutdown: mask of %SEND_SHUTDOWN and/or %RCV_SHUTDOWN
148 * @sk_userlocks: %SO_SNDBUF and %SO_RCVBUF settings
149 * @sk_lock: synchronizer
150 * @sk_rcvbuf: size of receive buffer in bytes
151 * @sk_sleep: sock wait queue
152 * @sk_dst_cache: destination cache
153 * @sk_dst_lock: destination cache lock
154 * @sk_policy: flow policy
155 * @sk_rmem_alloc: receive queue bytes committed
156 * @sk_receive_queue: incoming packets
157 * @sk_wmem_alloc: transmit queue bytes committed
158 * @sk_write_queue: Packet sending queue
Chris Leech97fc2f02006-05-23 17:55:33 -0700159 * @sk_async_wait_queue: DMA copied packets
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700160 * @sk_omem_alloc: "o" is "option" or "other"
161 * @sk_wmem_queued: persistent queue size
162 * @sk_forward_alloc: space allocated forward
163 * @sk_allocation: allocation mode
164 * @sk_sndbuf: size of send buffer in bytes
Wang Chen33c732c2007-11-13 20:30:01 -0800165 * @sk_flags: %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
Patrick Ohly20d49472009-02-12 05:03:38 +0000166 * %SO_OOBINLINE settings, %SO_TIMESTAMPING settings
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700167 * @sk_no_check: %SO_NO_CHECK setting, wether or not checkup packets
168 * @sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)
Herbert Xubcd76112006-06-30 13:36:35 -0700169 * @sk_gso_type: GSO type (e.g. %SKB_GSO_TCPV4)
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -0700170 * @sk_gso_max_size: Maximum GSO segment size to build
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700171 * @sk_lingertime: %SO_LINGER l_linger setting
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700172 * @sk_backlog: always used with the per-socket spinlock held
173 * @sk_callback_lock: used with the callbacks in the end of this struct
174 * @sk_error_queue: rarely used
Wang Chen33c732c2007-11-13 20:30:01 -0800175 * @sk_prot_creator: sk_prot of original sock creator (see ipv6_setsockopt,
176 * IPV6_ADDRFORM for instance)
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700177 * @sk_err: last error
Wang Chen33c732c2007-11-13 20:30:01 -0800178 * @sk_err_soft: errors that don't cause failure but are the cause of a
179 * persistent failure not just 'timed out'
Eric Dumazetcb61cb92008-06-17 21:04:56 -0700180 * @sk_drops: raw/udp drops counter
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700181 * @sk_ack_backlog: current listen backlog
182 * @sk_max_ack_backlog: listen backlog set in listen()
183 * @sk_priority: %SO_PRIORITY setting
184 * @sk_type: socket type (%SOCK_STREAM, etc)
185 * @sk_protocol: which protocol this socket belongs in this network family
186 * @sk_peercred: %SO_PEERCRED setting
187 * @sk_rcvlowat: %SO_RCVLOWAT setting
188 * @sk_rcvtimeo: %SO_RCVTIMEO setting
189 * @sk_sndtimeo: %SO_SNDTIMEO setting
190 * @sk_filter: socket filtering instructions
191 * @sk_protinfo: private area, net family specific, when not using slab
192 * @sk_timer: sock cleanup timer
193 * @sk_stamp: time stamp of last packet received
194 * @sk_socket: Identd and reporting IO signals
195 * @sk_user_data: RPC layer private data
196 * @sk_sndmsg_page: cached page for sendmsg
197 * @sk_sndmsg_off: cached offset for sendmsg
198 * @sk_send_head: front of stuff to transmit
Martin Waitz67be2dd2005-05-01 08:59:26 -0700199 * @sk_security: used by security modules
Randy Dunlap31729362008-02-18 20:52:13 -0800200 * @sk_mark: generic packet mark
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700201 * @sk_write_pending: a write to stream socket waits to start
202 * @sk_state_change: callback to indicate change in the state of the sock
203 * @sk_data_ready: callback to indicate there is data to be processed
204 * @sk_write_space: callback to indicate there is bf sending space available
205 * @sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)
206 * @sk_backlog_rcv: callback to process the backlog
207 * @sk_destruct: called at sock freeing time, i.e. when all refcnt == 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 */
209struct sock {
210 /*
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700211 * Now struct inet_timewait_sock also uses sock_common, so please just
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 * don't add nothing before this first member (__sk_common) --acme
213 */
214 struct sock_common __sk_common;
Eric Dumazet4dc6dc72009-07-15 23:13:10 +0000215#define sk_node __sk_common.skc_node
216#define sk_nulls_node __sk_common.skc_nulls_node
217#define sk_refcnt __sk_common.skc_refcnt
218
219#define sk_copy_start __sk_common.skc_hash
220#define sk_hash __sk_common.skc_hash
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221#define sk_family __sk_common.skc_family
222#define sk_state __sk_common.skc_state
223#define sk_reuse __sk_common.skc_reuse
224#define sk_bound_dev_if __sk_common.skc_bound_dev_if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225#define sk_bind_node __sk_common.skc_bind_node
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700226#define sk_prot __sk_common.skc_prot
Eric W. Biederman07feaeb2007-09-12 11:58:02 +0200227#define sk_net __sk_common.skc_net
Vegard Nossuma98b65a2009-02-26 14:46:57 +0100228 kmemcheck_bitfield_begin(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 unsigned char sk_shutdown : 2,
230 sk_no_check : 2,
231 sk_userlocks : 4;
Vegard Nossuma98b65a2009-02-26 14:46:57 +0100232 kmemcheck_bitfield_end(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 unsigned char sk_protocol;
234 unsigned short sk_type;
235 int sk_rcvbuf;
236 socket_lock_t sk_lock;
Eric Dumazetfa438cc2007-03-04 16:05:44 -0800237 /*
238 * The backlog queue is special, it is always used with
239 * the per-socket spinlock held and requires low latency
240 * access. Therefore we special case it's implementation.
241 */
242 struct {
243 struct sk_buff *head;
244 struct sk_buff *tail;
245 } sk_backlog;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 wait_queue_head_t *sk_sleep;
247 struct dst_entry *sk_dst_cache;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700248#ifdef CONFIG_XFRM
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 struct xfrm_policy *sk_policy[2];
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700250#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 rwlock_t sk_dst_lock;
252 atomic_t sk_rmem_alloc;
253 atomic_t sk_wmem_alloc;
254 atomic_t sk_omem_alloc;
Arnaldo Carvalho de Melo4e07a912007-05-29 13:17:47 -0700255 int sk_sndbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 struct sk_buff_head sk_receive_queue;
257 struct sk_buff_head sk_write_queue;
Alexey Dobriyan23789822008-11-12 23:25:32 -0800258#ifdef CONFIG_NET_DMA
Chris Leech97fc2f02006-05-23 17:55:33 -0700259 struct sk_buff_head sk_async_wait_queue;
Alexey Dobriyan23789822008-11-12 23:25:32 -0800260#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 int sk_wmem_queued;
262 int sk_forward_alloc;
Al Viro7d877f32005-10-21 03:20:43 -0400263 gfp_t sk_allocation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 int sk_route_caps;
Herbert Xubcd76112006-06-30 13:36:35 -0700265 int sk_gso_type;
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -0700266 unsigned int sk_gso_max_size;
David S. Miller9932cf92006-03-24 15:12:37 -0800267 int sk_rcvlowat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 unsigned long sk_flags;
269 unsigned long sk_lingertime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 struct sk_buff_head sk_error_queue;
Arnaldo Carvalho de Melo476e19c2005-05-05 13:35:15 -0700271 struct proto *sk_prot_creator;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 rwlock_t sk_callback_lock;
273 int sk_err,
274 sk_err_soft;
Wang Chen33c732c2007-11-13 20:30:01 -0800275 atomic_t sk_drops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 unsigned short sk_ack_backlog;
277 unsigned short sk_max_ack_backlog;
278 __u32 sk_priority;
279 struct ucred sk_peercred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 long sk_rcvtimeo;
281 long sk_sndtimeo;
282 struct sk_filter *sk_filter;
283 void *sk_protinfo;
284 struct timer_list sk_timer;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700285 ktime_t sk_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 struct socket *sk_socket;
287 void *sk_user_data;
288 struct page *sk_sndmsg_page;
289 struct sk_buff *sk_send_head;
290 __u32 sk_sndmsg_off;
291 int sk_write_pending;
Alexey Dobriyand5f64232008-11-04 14:45:58 -0800292#ifdef CONFIG_SECURITY
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 void *sk_security;
Alexey Dobriyand5f64232008-11-04 14:45:58 -0800294#endif
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800295 __u32 sk_mark;
296 /* XXX 4 bytes hole on 64 bit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 void (*sk_state_change)(struct sock *sk);
298 void (*sk_data_ready)(struct sock *sk, int bytes);
299 void (*sk_write_space)(struct sock *sk);
300 void (*sk_error_report)(struct sock *sk);
301 int (*sk_backlog_rcv)(struct sock *sk,
302 struct sk_buff *skb);
303 void (*sk_destruct)(struct sock *sk);
304};
305
306/*
307 * Hashed lists helper routines
308 */
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700309static inline struct sock *__sk_head(const struct hlist_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310{
311 return hlist_entry(head->first, struct sock, sk_node);
312}
313
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700314static inline struct sock *sk_head(const struct hlist_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
316 return hlist_empty(head) ? NULL : __sk_head(head);
317}
318
Eric Dumazet88ab1932008-11-16 19:39:21 -0800319static inline struct sock *__sk_nulls_head(const struct hlist_nulls_head *head)
320{
321 return hlist_nulls_entry(head->first, struct sock, sk_nulls_node);
322}
323
324static inline struct sock *sk_nulls_head(const struct hlist_nulls_head *head)
325{
326 return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
327}
328
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700329static inline struct sock *sk_next(const struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
331 return sk->sk_node.next ?
332 hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
333}
334
Eric Dumazet88ab1932008-11-16 19:39:21 -0800335static inline struct sock *sk_nulls_next(const struct sock *sk)
336{
337 return (!is_a_nulls(sk->sk_nulls_node.next)) ?
338 hlist_nulls_entry(sk->sk_nulls_node.next,
339 struct sock, sk_nulls_node) :
340 NULL;
341}
342
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700343static inline int sk_unhashed(const struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344{
345 return hlist_unhashed(&sk->sk_node);
346}
347
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700348static inline int sk_hashed(const struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349{
Akinobu Mitada753be2006-04-28 15:21:23 -0700350 return !sk_unhashed(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
353static __inline__ void sk_node_init(struct hlist_node *node)
354{
355 node->pprev = NULL;
356}
357
Eric Dumazet88ab1932008-11-16 19:39:21 -0800358static __inline__ void sk_nulls_node_init(struct hlist_nulls_node *node)
359{
360 node->pprev = NULL;
361}
362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363static __inline__ void __sk_del_node(struct sock *sk)
364{
365 __hlist_del(&sk->sk_node);
366}
367
368static __inline__ int __sk_del_node_init(struct sock *sk)
369{
370 if (sk_hashed(sk)) {
371 __sk_del_node(sk);
372 sk_node_init(&sk->sk_node);
373 return 1;
374 }
375 return 0;
376}
377
378/* Grab socket reference count. This operation is valid only
379 when sk is ALREADY grabbed f.e. it is found in hash table
380 or a list and the lookup is made under lock preventing hash table
381 modifications.
382 */
383
384static inline void sock_hold(struct sock *sk)
385{
386 atomic_inc(&sk->sk_refcnt);
387}
388
389/* Ungrab socket in the context, which assumes that socket refcnt
390 cannot hit zero, f.e. it is true in context of any socketcall.
391 */
392static inline void __sock_put(struct sock *sk)
393{
394 atomic_dec(&sk->sk_refcnt);
395}
396
397static __inline__ int sk_del_node_init(struct sock *sk)
398{
399 int rc = __sk_del_node_init(sk);
400
401 if (rc) {
402 /* paranoid for a while -acme */
403 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
404 __sock_put(sk);
405 }
406 return rc;
407}
408
Eric Dumazet88ab1932008-11-16 19:39:21 -0800409static __inline__ int __sk_nulls_del_node_init_rcu(struct sock *sk)
Eric Dumazet271b72c2008-10-29 02:11:14 -0700410{
411 if (sk_hashed(sk)) {
Eric Dumazet88ab1932008-11-16 19:39:21 -0800412 hlist_nulls_del_init_rcu(&sk->sk_nulls_node);
Eric Dumazet271b72c2008-10-29 02:11:14 -0700413 return 1;
414 }
415 return 0;
416}
417
Eric Dumazet88ab1932008-11-16 19:39:21 -0800418static __inline__ int sk_nulls_del_node_init_rcu(struct sock *sk)
Eric Dumazet271b72c2008-10-29 02:11:14 -0700419{
Eric Dumazet88ab1932008-11-16 19:39:21 -0800420 int rc = __sk_nulls_del_node_init_rcu(sk);
Eric Dumazet271b72c2008-10-29 02:11:14 -0700421
422 if (rc) {
423 /* paranoid for a while -acme */
424 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
425 __sock_put(sk);
426 }
427 return rc;
428}
429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list)
431{
432 hlist_add_head(&sk->sk_node, list);
433}
434
435static __inline__ void sk_add_node(struct sock *sk, struct hlist_head *list)
436{
437 sock_hold(sk);
438 __sk_add_node(sk, list);
439}
440
Eric Dumazet88ab1932008-11-16 19:39:21 -0800441static __inline__ void __sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
Eric Dumazet271b72c2008-10-29 02:11:14 -0700442{
Eric Dumazet88ab1932008-11-16 19:39:21 -0800443 hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
Eric Dumazet271b72c2008-10-29 02:11:14 -0700444}
445
Eric Dumazet88ab1932008-11-16 19:39:21 -0800446static __inline__ void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
Eric Dumazet271b72c2008-10-29 02:11:14 -0700447{
448 sock_hold(sk);
Eric Dumazet88ab1932008-11-16 19:39:21 -0800449 __sk_nulls_add_node_rcu(sk, list);
Eric Dumazet271b72c2008-10-29 02:11:14 -0700450}
451
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452static __inline__ void __sk_del_bind_node(struct sock *sk)
453{
454 __hlist_del(&sk->sk_bind_node);
455}
456
457static __inline__ void sk_add_bind_node(struct sock *sk,
458 struct hlist_head *list)
459{
460 hlist_add_head(&sk->sk_bind_node, list);
461}
462
463#define sk_for_each(__sk, node, list) \
464 hlist_for_each_entry(__sk, node, list, sk_node)
Eric Dumazet88ab1932008-11-16 19:39:21 -0800465#define sk_nulls_for_each(__sk, node, list) \
466 hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)
467#define sk_nulls_for_each_rcu(__sk, node, list) \
468 hlist_nulls_for_each_entry_rcu(__sk, node, list, sk_nulls_node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469#define sk_for_each_from(__sk, node) \
470 if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
471 hlist_for_each_entry_from(__sk, node, sk_node)
Eric Dumazet88ab1932008-11-16 19:39:21 -0800472#define sk_nulls_for_each_from(__sk, node) \
473 if (__sk && ({ node = &(__sk)->sk_nulls_node; 1; })) \
474 hlist_nulls_for_each_entry_from(__sk, node, sk_nulls_node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475#define sk_for_each_continue(__sk, node) \
476 if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
477 hlist_for_each_entry_continue(__sk, node, sk_node)
478#define sk_for_each_safe(__sk, node, tmp, list) \
479 hlist_for_each_entry_safe(__sk, node, tmp, list, sk_node)
480#define sk_for_each_bound(__sk, node, list) \
481 hlist_for_each_entry(__sk, node, list, sk_bind_node)
482
483/* Sock flags */
484enum sock_flags {
485 SOCK_DEAD,
486 SOCK_DONE,
487 SOCK_URGINLINE,
488 SOCK_KEEPOPEN,
489 SOCK_LINGER,
490 SOCK_DESTROY,
491 SOCK_BROADCAST,
492 SOCK_TIMESTAMP,
493 SOCK_ZAPPED,
494 SOCK_USE_WRITE_QUEUE, /* whether to call sk->sk_write_space in sock_wfree */
495 SOCK_DBG, /* %SO_DEBUG setting */
496 SOCK_RCVTSTAMP, /* %SO_TIMESTAMP setting */
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700497 SOCK_RCVTSTAMPNS, /* %SO_TIMESTAMPNS setting */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 SOCK_LOCALROUTE, /* route locally only, %SO_DONTROUTE setting */
499 SOCK_QUEUE_SHRUNK, /* write queue has been shrunk recently */
Patrick Ohly20d49472009-02-12 05:03:38 +0000500 SOCK_TIMESTAMPING_TX_HARDWARE, /* %SOF_TIMESTAMPING_TX_HARDWARE */
501 SOCK_TIMESTAMPING_TX_SOFTWARE, /* %SOF_TIMESTAMPING_TX_SOFTWARE */
502 SOCK_TIMESTAMPING_RX_HARDWARE, /* %SOF_TIMESTAMPING_RX_HARDWARE */
503 SOCK_TIMESTAMPING_RX_SOFTWARE, /* %SOF_TIMESTAMPING_RX_SOFTWARE */
504 SOCK_TIMESTAMPING_SOFTWARE, /* %SOF_TIMESTAMPING_SOFTWARE */
505 SOCK_TIMESTAMPING_RAW_HARDWARE, /* %SOF_TIMESTAMPING_RAW_HARDWARE */
506 SOCK_TIMESTAMPING_SYS_HARDWARE, /* %SOF_TIMESTAMPING_SYS_HARDWARE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507};
508
Ralf Baechle53b924b2005-08-23 10:11:30 -0700509static inline void sock_copy_flags(struct sock *nsk, struct sock *osk)
510{
511 nsk->sk_flags = osk->sk_flags;
512}
513
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514static inline void sock_set_flag(struct sock *sk, enum sock_flags flag)
515{
516 __set_bit(flag, &sk->sk_flags);
517}
518
519static inline void sock_reset_flag(struct sock *sk, enum sock_flags flag)
520{
521 __clear_bit(flag, &sk->sk_flags);
522}
523
524static inline int sock_flag(struct sock *sk, enum sock_flags flag)
525{
526 return test_bit(flag, &sk->sk_flags);
527}
528
529static inline void sk_acceptq_removed(struct sock *sk)
530{
531 sk->sk_ack_backlog--;
532}
533
534static inline void sk_acceptq_added(struct sock *sk)
535{
536 sk->sk_ack_backlog++;
537}
538
539static inline int sk_acceptq_is_full(struct sock *sk)
540{
David S. Miller64a14652007-03-06 11:21:05 -0800541 return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
543
544/*
545 * Compute minimal free write space needed to queue new packets.
546 */
547static inline int sk_stream_min_wspace(struct sock *sk)
548{
Eric Dumazet8df09ea2007-12-21 03:07:41 -0800549 return sk->sk_wmem_queued >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550}
551
552static inline int sk_stream_wspace(struct sock *sk)
553{
554 return sk->sk_sndbuf - sk->sk_wmem_queued;
555}
556
557extern void sk_stream_write_space(struct sock *sk);
558
559static inline int sk_stream_memory_free(struct sock *sk)
560{
561 return sk->sk_wmem_queued < sk->sk_sndbuf;
562}
563
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564/* The per-socket spinlock must be held here. */
Stephen Hemminger9ee6b532005-11-08 09:39:42 -0800565static inline void sk_add_backlog(struct sock *sk, struct sk_buff *skb)
566{
567 if (!sk->sk_backlog.tail) {
568 sk->sk_backlog.head = sk->sk_backlog.tail = skb;
569 } else {
570 sk->sk_backlog.tail->next = skb;
571 sk->sk_backlog.tail = skb;
572 }
573 skb->next = NULL;
574}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Peter Zijlstrac57943a2008-10-07 14:18:42 -0700576static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
577{
578 return sk->sk_backlog_rcv(sk, skb);
579}
580
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700581#define sk_wait_event(__sk, __timeo, __condition) \
582 ({ int __rc; \
583 release_sock(__sk); \
584 __rc = __condition; \
585 if (!__rc) { \
586 *(__timeo) = schedule_timeout(*(__timeo)); \
587 } \
588 lock_sock(__sk); \
589 __rc = __condition; \
590 __rc; \
591 })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593extern int sk_stream_wait_connect(struct sock *sk, long *timeo_p);
594extern int sk_stream_wait_memory(struct sock *sk, long *timeo_p);
595extern void sk_stream_wait_close(struct sock *sk, long timeo_p);
596extern int sk_stream_error(struct sock *sk, int flags, int err);
597extern void sk_stream_kill_queues(struct sock *sk);
598
599extern int sk_wait_data(struct sock *sk, long *timeo);
600
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700601struct request_sock_ops;
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800602struct timewait_sock_ops;
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -0800603struct inet_hashinfo;
Pavel Emelyanovfc8717b2008-03-22 16:56:51 -0700604struct raw_hashinfo;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606/* Networking protocol blocks we attach to sockets.
607 * socket layer -> transport layer interface
608 * transport -> network interface is defined by struct inet_proto
609 */
610struct proto {
611 void (*close)(struct sock *sk,
612 long timeout);
613 int (*connect)(struct sock *sk,
614 struct sockaddr *uaddr,
615 int addr_len);
616 int (*disconnect)(struct sock *sk, int flags);
617
618 struct sock * (*accept) (struct sock *sk, int flags, int *err);
619
620 int (*ioctl)(struct sock *sk, int cmd,
621 unsigned long arg);
622 int (*init)(struct sock *sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -0700623 void (*destroy)(struct sock *sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 void (*shutdown)(struct sock *sk, int how);
625 int (*setsockopt)(struct sock *sk, int level,
626 int optname, char __user *optval,
627 int optlen);
628 int (*getsockopt)(struct sock *sk, int level,
629 int optname, char __user *optval,
630 int __user *option);
Alexey Dobriyanaf01d532008-08-28 02:53:51 -0700631#ifdef CONFIG_COMPAT
Dmitry Mishin3fdadf72006-03-20 22:45:21 -0800632 int (*compat_setsockopt)(struct sock *sk,
633 int level,
634 int optname, char __user *optval,
635 int optlen);
636 int (*compat_getsockopt)(struct sock *sk,
637 int level,
638 int optname, char __user *optval,
639 int __user *option);
Alexey Dobriyanaf01d532008-08-28 02:53:51 -0700640#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 int (*sendmsg)(struct kiocb *iocb, struct sock *sk,
642 struct msghdr *msg, size_t len);
643 int (*recvmsg)(struct kiocb *iocb, struct sock *sk,
644 struct msghdr *msg,
645 size_t len, int noblock, int flags,
646 int *addr_len);
647 int (*sendpage)(struct sock *sk, struct page *page,
648 int offset, size_t size, int flags);
649 int (*bind)(struct sock *sk,
650 struct sockaddr *uaddr, int addr_len);
651
652 int (*backlog_rcv) (struct sock *sk,
653 struct sk_buff *skb);
654
655 /* Keeping track of sk's, looking them up, and port selection methods. */
656 void (*hash)(struct sock *sk);
657 void (*unhash)(struct sock *sk);
658 int (*get_port)(struct sock *sk, unsigned short snum);
659
Eric Dumazet286ab3d2007-11-05 23:38:39 -0800660 /* Keeping track of sockets in use */
Eric Dumazet65f76512008-01-03 20:46:48 -0800661#ifdef CONFIG_PROC_FS
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -0700662 unsigned int inuse_idx;
Eric Dumazet65f76512008-01-03 20:46:48 -0800663#endif
Arnaldo Carvalho de Meloebb53d72007-11-21 22:08:50 +0800664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 /* Memory pressure */
Pavel Emelyanov5c52ba12008-07-16 20:28:10 -0700666 void (*enter_memory_pressure)(struct sock *sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 atomic_t *memory_allocated; /* Current allocated memory. */
Eric Dumazet17483762008-11-25 21:16:35 -0800668 struct percpu_counter *sockets_allocated; /* Current number of sockets. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 /*
670 * Pressure flag: try to collapse.
671 * Technical note: it is used by multiple contexts non atomically.
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800672 * All the __sk_mem_schedule() is of this nature: accounting
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 * is strict, actions are advisory and have some latency.
674 */
675 int *memory_pressure;
676 int *sysctl_mem;
677 int *sysctl_wmem;
678 int *sysctl_rmem;
679 int max_header;
680
Eric Dumazet271b72c2008-10-29 02:11:14 -0700681 struct kmem_cache *slab;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 unsigned int obj_size;
Eric Dumazet271b72c2008-10-29 02:11:14 -0700683 int slab_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
Eric Dumazetdd24c002008-11-25 21:17:14 -0800685 struct percpu_counter *orphan_count;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700686
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700687 struct request_sock_ops *rsk_prot;
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800688 struct timewait_sock_ops *twsk_prot;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700689
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -0700690 union {
691 struct inet_hashinfo *hashinfo;
Eric Dumazet645ca702008-10-29 01:41:45 -0700692 struct udp_table *udp_table;
Pavel Emelyanovfc8717b2008-03-22 16:56:51 -0700693 struct raw_hashinfo *raw_hash;
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -0700694 } h;
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -0800695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 struct module *owner;
697
698 char name[32];
699
700 struct list_head node;
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -0700701#ifdef SOCK_REFCNT_DEBUG
702 atomic_t socks;
703#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704};
705
706extern int proto_register(struct proto *prot, int alloc_slab);
707extern void proto_unregister(struct proto *prot);
708
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -0700709#ifdef SOCK_REFCNT_DEBUG
710static inline void sk_refcnt_debug_inc(struct sock *sk)
711{
712 atomic_inc(&sk->sk_prot->socks);
713}
714
715static inline void sk_refcnt_debug_dec(struct sock *sk)
716{
717 atomic_dec(&sk->sk_prot->socks);
718 printk(KERN_DEBUG "%s socket %p released, %d are still alive\n",
719 sk->sk_prot->name, sk, atomic_read(&sk->sk_prot->socks));
720}
721
722static inline void sk_refcnt_debug_release(const struct sock *sk)
723{
724 if (atomic_read(&sk->sk_refcnt) != 1)
725 printk(KERN_DEBUG "Destruction of the %s socket %p delayed, refcnt=%d\n",
726 sk->sk_prot->name, sk, atomic_read(&sk->sk_refcnt));
727}
728#else /* SOCK_REFCNT_DEBUG */
729#define sk_refcnt_debug_inc(sk) do { } while (0)
730#define sk_refcnt_debug_dec(sk) do { } while (0)
731#define sk_refcnt_debug_release(sk) do { } while (0)
732#endif /* SOCK_REFCNT_DEBUG */
733
Eric Dumazet65f76512008-01-03 20:46:48 -0800734
735#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736/* Called with local bh disabled */
Pavel Emelyanovc29a0bc2008-03-31 19:41:46 -0700737extern void sock_prot_inuse_add(struct net *net, struct proto *prot, int inc);
738extern int sock_prot_inuse_get(struct net *net, struct proto *proto);
Eric Dumazet65f76512008-01-03 20:46:48 -0800739#else
Pavel Emelyanovc29a0bc2008-03-31 19:41:46 -0700740static void inline sock_prot_inuse_add(struct net *net, struct proto *prot,
741 int inc)
Eric Dumazet65f76512008-01-03 20:46:48 -0800742{
743}
Eric Dumazet65f76512008-01-03 20:46:48 -0800744#endif
745
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Arnaldo Carvalho de Melo614c6cb2005-08-09 19:47:37 -0700747/* With per-bucket locks this operation is not-atomic, so that
748 * this version is not worse.
749 */
750static inline void __sk_prot_rehash(struct sock *sk)
751{
752 sk->sk_prot->unhash(sk);
753 sk->sk_prot->hash(sk);
754}
755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756/* About 10 seconds */
757#define SOCK_DESTROY_TIME (10*HZ)
758
759/* Sockets 0-1023 can't be bound to unless you are superuser */
760#define PROT_SOCK 1024
761
762#define SHUTDOWN_MASK 3
763#define RCV_SHUTDOWN 1
764#define SEND_SHUTDOWN 2
765
766#define SOCK_SNDBUF_LOCK 1
767#define SOCK_RCVBUF_LOCK 2
768#define SOCK_BINDADDR_LOCK 4
769#define SOCK_BINDPORT_LOCK 8
770
771/* sock_iocb: used to kick off async processing of socket ios */
772struct sock_iocb {
773 struct list_head list;
774
775 int flags;
776 int size;
777 struct socket *sock;
778 struct sock *sk;
779 struct scm_cookie *scm;
780 struct msghdr *msg, async_msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 struct kiocb *kiocb;
782};
783
784static inline struct sock_iocb *kiocb_to_siocb(struct kiocb *iocb)
785{
786 return (struct sock_iocb *)iocb->private;
787}
788
789static inline struct kiocb *siocb_to_kiocb(struct sock_iocb *si)
790{
791 return si->kiocb;
792}
793
794struct socket_alloc {
795 struct socket socket;
796 struct inode vfs_inode;
797};
798
799static inline struct socket *SOCKET_I(struct inode *inode)
800{
801 return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
802}
803
804static inline struct inode *SOCK_INODE(struct socket *socket)
805{
806 return &container_of(socket, struct socket_alloc, socket)->vfs_inode;
807}
808
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800809/*
810 * Functions for memory accounting
811 */
812extern int __sk_mem_schedule(struct sock *sk, int size, int kind);
813extern void __sk_mem_reclaim(struct sock *sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800815#define SK_MEM_QUANTUM ((int)PAGE_SIZE)
816#define SK_MEM_QUANTUM_SHIFT ilog2(SK_MEM_QUANTUM)
817#define SK_MEM_SEND 0
818#define SK_MEM_RECV 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800820static inline int sk_mem_pages(int amt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821{
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800822 return (amt + SK_MEM_QUANTUM - 1) >> SK_MEM_QUANTUM_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823}
824
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800825static inline int sk_has_account(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826{
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800827 /* return true if protocol supports memory accounting */
828 return !!sk->sk_prot->memory_allocated;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800831static inline int sk_wmem_schedule(struct sock *sk, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832{
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800833 if (!sk_has_account(sk))
834 return 1;
Herbert Xud80d99d2005-09-01 17:48:23 -0700835 return size <= sk->sk_forward_alloc ||
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800836 __sk_mem_schedule(sk, size, SK_MEM_SEND);
837}
838
839static inline int sk_rmem_schedule(struct sock *sk, int size)
840{
841 if (!sk_has_account(sk))
842 return 1;
843 return size <= sk->sk_forward_alloc ||
844 __sk_mem_schedule(sk, size, SK_MEM_RECV);
845}
846
847static inline void sk_mem_reclaim(struct sock *sk)
848{
849 if (!sk_has_account(sk))
850 return;
851 if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
852 __sk_mem_reclaim(sk);
853}
854
David S. Miller9993e7d2008-01-10 21:56:38 -0800855static inline void sk_mem_reclaim_partial(struct sock *sk)
856{
857 if (!sk_has_account(sk))
858 return;
859 if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
860 __sk_mem_reclaim(sk);
861}
862
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800863static inline void sk_mem_charge(struct sock *sk, int size)
864{
865 if (!sk_has_account(sk))
866 return;
867 sk->sk_forward_alloc -= size;
868}
869
870static inline void sk_mem_uncharge(struct sock *sk, int size)
871{
872 if (!sk_has_account(sk))
873 return;
874 sk->sk_forward_alloc += size;
875}
876
877static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
878{
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800879 sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
880 sk->sk_wmem_queued -= skb->truesize;
881 sk_mem_uncharge(sk, skb->truesize);
882 __kfree_skb(skb);
Herbert Xud80d99d2005-09-01 17:48:23 -0700883}
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885/* Used by processes to "lock" a socket state, so that
886 * interrupts and bottom half handlers won't change it
887 * from under us. It essentially blocks any incoming
888 * packets, so that we won't get any new data or any
889 * packets that change the state of the socket.
890 *
891 * While locked, BH processing will add new packets to
892 * the backlog queue. This queue is processed by the
893 * owner of the socket lock right before it is released.
894 *
895 * Since ~2.3.5 it is also exclusive sleep lock serializing
896 * accesses from user process context.
897 */
John Heffnerd2e91172007-09-12 10:44:19 +0200898#define sock_owned_by_user(sk) ((sk)->sk_lock.owned)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
Peter Zijlstraed075362006-12-06 20:35:24 -0800900/*
901 * Macro so as to not evaluate some arguments when
902 * lockdep is not enabled.
903 *
904 * Mark both the sk_lock and the sk_lock.slock as a
905 * per-address-family lock class.
906 */
907#define sock_lock_init_class_and_name(sk, sname, skey, name, key) \
908do { \
Ingo Molnare8f6fbf2008-11-12 01:38:36 +0000909 sk->sk_lock.owned = 0; \
Peter Zijlstraed075362006-12-06 20:35:24 -0800910 init_waitqueue_head(&sk->sk_lock.wq); \
911 spin_lock_init(&(sk)->sk_lock.slock); \
912 debug_check_no_locks_freed((void *)&(sk)->sk_lock, \
913 sizeof((sk)->sk_lock)); \
914 lockdep_set_class_and_name(&(sk)->sk_lock.slock, \
915 (skey), (sname)); \
916 lockdep_init_map(&(sk)->sk_lock.dep_map, (name), (key), 0); \
917} while (0)
918
Harvey Harrison41380932007-12-12 10:46:51 -0800919extern void lock_sock_nested(struct sock *sk, int subclass);
Peter Zijlstrafcc70d52006-11-08 22:44:35 -0800920
921static inline void lock_sock(struct sock *sk)
922{
923 lock_sock_nested(sk, 0);
924}
925
Harvey Harrison41380932007-12-12 10:46:51 -0800926extern void release_sock(struct sock *sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
928/* BH context may only use the following locking interface. */
929#define bh_lock_sock(__sk) spin_lock(&((__sk)->sk_lock.slock))
Ingo Molnarc6366182006-07-03 00:25:13 -0700930#define bh_lock_sock_nested(__sk) \
931 spin_lock_nested(&((__sk)->sk_lock.slock), \
932 SINGLE_DEPTH_NESTING)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933#define bh_unlock_sock(__sk) spin_unlock(&((__sk)->sk_lock.slock))
934
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700935extern struct sock *sk_alloc(struct net *net, int family,
Al Virodd0fc662005-10-07 07:46:04 +0100936 gfp_t priority,
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700937 struct proto *prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938extern void sk_free(struct sock *sk);
Denis V. Lunevedf02082008-02-29 11:18:32 -0800939extern void sk_release_kernel(struct sock *sk);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -0700940extern struct sock *sk_clone(const struct sock *sk,
Al Virodd0fc662005-10-07 07:46:04 +0100941 const gfp_t priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
943extern struct sk_buff *sock_wmalloc(struct sock *sk,
944 unsigned long size, int force,
Al Virodd0fc662005-10-07 07:46:04 +0100945 gfp_t priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946extern struct sk_buff *sock_rmalloc(struct sock *sk,
947 unsigned long size, int force,
Al Virodd0fc662005-10-07 07:46:04 +0100948 gfp_t priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949extern void sock_wfree(struct sk_buff *skb);
950extern void sock_rfree(struct sk_buff *skb);
951
952extern int sock_setsockopt(struct socket *sock, int level,
953 int op, char __user *optval,
954 int optlen);
955
956extern int sock_getsockopt(struct socket *sock, int level,
957 int op, char __user *optval,
958 int __user *optlen);
959extern struct sk_buff *sock_alloc_send_skb(struct sock *sk,
960 unsigned long size,
961 int noblock,
962 int *errcode);
Herbert Xu4cc7f682009-02-04 16:55:54 -0800963extern struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
964 unsigned long header_len,
965 unsigned long data_len,
966 int noblock,
967 int *errcode);
Victor Fusco86a76ca2005-07-08 14:57:47 -0700968extern void *sock_kmalloc(struct sock *sk, int size,
Al Virodd0fc662005-10-07 07:46:04 +0100969 gfp_t priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970extern void sock_kfree_s(struct sock *sk, void *mem, int size);
971extern void sk_send_sigurg(struct sock *sk);
972
973/*
974 * Functions to fill in entries in struct proto_ops when a protocol
975 * does not implement a particular function.
976 */
977extern int sock_no_bind(struct socket *,
978 struct sockaddr *, int);
979extern int sock_no_connect(struct socket *,
980 struct sockaddr *, int, int);
981extern int sock_no_socketpair(struct socket *,
982 struct socket *);
983extern int sock_no_accept(struct socket *,
984 struct socket *, int);
985extern int sock_no_getname(struct socket *,
986 struct sockaddr *, int *, int);
987extern unsigned int sock_no_poll(struct file *, struct socket *,
988 struct poll_table_struct *);
989extern int sock_no_ioctl(struct socket *, unsigned int,
990 unsigned long);
991extern int sock_no_listen(struct socket *, int);
992extern int sock_no_shutdown(struct socket *, int);
993extern int sock_no_getsockopt(struct socket *, int , int,
994 char __user *, int __user *);
995extern int sock_no_setsockopt(struct socket *, int, int,
996 char __user *, int);
997extern int sock_no_sendmsg(struct kiocb *, struct socket *,
998 struct msghdr *, size_t);
999extern int sock_no_recvmsg(struct kiocb *, struct socket *,
1000 struct msghdr *, size_t, int);
1001extern int sock_no_mmap(struct file *file,
1002 struct socket *sock,
1003 struct vm_area_struct *vma);
1004extern ssize_t sock_no_sendpage(struct socket *sock,
1005 struct page *page,
1006 int offset, size_t size,
1007 int flags);
1008
1009/*
1010 * Functions to fill in entries in struct proto_ops when a protocol
1011 * uses the inet style.
1012 */
1013extern int sock_common_getsockopt(struct socket *sock, int level, int optname,
1014 char __user *optval, int __user *optlen);
1015extern int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1016 struct msghdr *msg, size_t size, int flags);
1017extern int sock_common_setsockopt(struct socket *sock, int level, int optname,
1018 char __user *optval, int optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001019extern int compat_sock_common_getsockopt(struct socket *sock, int level,
1020 int optname, char __user *optval, int __user *optlen);
1021extern int compat_sock_common_setsockopt(struct socket *sock, int level,
1022 int optname, char __user *optval, int optlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
1024extern void sk_common_release(struct sock *sk);
1025
1026/*
1027 * Default socket callbacks and setup code
1028 */
1029
1030/* Initialise core socket variables */
1031extern void sock_init_data(struct socket *sock, struct sock *sk);
1032
1033/**
Paul Bonserdc9b3342006-11-23 17:56:13 -08001034 * sk_filter_release: Release a socket filter
Paul Bonserdc9b3342006-11-23 17:56:13 -08001035 * @fp: filter to remove
1036 *
1037 * Remove a filter from a socket and release its resources.
1038 */
1039
Pavel Emelyanov309dd5f2007-10-17 21:21:51 -07001040static inline void sk_filter_release(struct sk_filter *fp)
1041{
1042 if (atomic_dec_and_test(&fp->refcnt))
Pavel Emelyanov47e958e2007-10-17 21:22:42 -07001043 kfree(fp);
Pavel Emelyanov309dd5f2007-10-17 21:21:51 -07001044}
1045
1046static inline void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047{
1048 unsigned int size = sk_filter_len(fp);
1049
1050 atomic_sub(size, &sk->sk_omem_alloc);
Pavel Emelyanov309dd5f2007-10-17 21:21:51 -07001051 sk_filter_release(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052}
1053
1054static inline void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
1055{
1056 atomic_inc(&fp->refcnt);
1057 atomic_add(sk_filter_len(fp), &sk->sk_omem_alloc);
1058}
1059
1060/*
1061 * Socket reference counting postulates.
1062 *
1063 * * Each user of socket SHOULD hold a reference count.
1064 * * Each access point to socket (an hash table bucket, reference from a list,
1065 * running timer, skb in flight MUST hold a reference count.
1066 * * When reference count hits 0, it means it will never increase back.
1067 * * When reference count hits 0, it means that no references from
1068 * outside exist to this socket and current process on current CPU
1069 * is last user and may/should destroy this socket.
1070 * * sk_free is called from any context: process, BH, IRQ. When
1071 * it is called, socket has no references from outside -> sk_free
1072 * may release descendant resources allocated by the socket, but
1073 * to the time when it is called, socket is NOT referenced by any
1074 * hash tables, lists etc.
1075 * * Packets, delivered from outside (from network or from another process)
1076 * and enqueued on receive/error queues SHOULD NOT grab reference count,
1077 * when they sit in queue. Otherwise, packets will leak to hole, when
1078 * socket is looked up by one cpu and unhasing is made by another CPU.
1079 * It is true for udp/raw, netlink (leak to receive and error queues), tcp
1080 * (leak to backlog). Packet socket does all the processing inside
1081 * BR_NETPROTO_LOCK, so that it has not this race condition. UNIX sockets
1082 * use separate SMP lock, so that they are prone too.
1083 */
1084
1085/* Ungrab socket and destroy it, if it was the last reference. */
1086static inline void sock_put(struct sock *sk)
1087{
1088 if (atomic_dec_and_test(&sk->sk_refcnt))
1089 sk_free(sk);
1090}
1091
Arnaldo Carvalho de Melo58a5a7b2006-11-16 14:06:06 -02001092extern int sk_receive_skb(struct sock *sk, struct sk_buff *skb,
1093 const int nested);
Arnaldo Carvalho de Melo25995ff2005-12-27 02:42:22 -02001094
David S. Miller972692e2008-06-17 22:41:38 -07001095static inline void sk_set_socket(struct sock *sk, struct socket *sock)
1096{
1097 sk->sk_socket = sock;
1098}
1099
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100/* Detach socket from process context.
1101 * Announce socket dead, detach it from wait queue and inode.
1102 * Note that parent inode held reference count on this struct sock,
1103 * we do not release it in this function, because protocol
1104 * probably wants some additional cleanups or even continuing
1105 * to work with this socket (TCP).
1106 */
1107static inline void sock_orphan(struct sock *sk)
1108{
1109 write_lock_bh(&sk->sk_callback_lock);
1110 sock_set_flag(sk, SOCK_DEAD);
David S. Miller972692e2008-06-17 22:41:38 -07001111 sk_set_socket(sk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 sk->sk_sleep = NULL;
1113 write_unlock_bh(&sk->sk_callback_lock);
1114}
1115
1116static inline void sock_graft(struct sock *sk, struct socket *parent)
1117{
1118 write_lock_bh(&sk->sk_callback_lock);
1119 sk->sk_sleep = &parent->wait;
1120 parent->sk = sk;
David S. Miller972692e2008-06-17 22:41:38 -07001121 sk_set_socket(sk, parent);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001122 security_sock_graft(sk, parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 write_unlock_bh(&sk->sk_callback_lock);
1124}
1125
1126extern int sock_i_uid(struct sock *sk);
1127extern unsigned long sock_i_ino(struct sock *sk);
1128
1129static inline struct dst_entry *
1130__sk_dst_get(struct sock *sk)
1131{
1132 return sk->sk_dst_cache;
1133}
1134
1135static inline struct dst_entry *
1136sk_dst_get(struct sock *sk)
1137{
1138 struct dst_entry *dst;
1139
1140 read_lock(&sk->sk_dst_lock);
1141 dst = sk->sk_dst_cache;
1142 if (dst)
1143 dst_hold(dst);
1144 read_unlock(&sk->sk_dst_lock);
1145 return dst;
1146}
1147
1148static inline void
1149__sk_dst_set(struct sock *sk, struct dst_entry *dst)
1150{
1151 struct dst_entry *old_dst;
1152
1153 old_dst = sk->sk_dst_cache;
1154 sk->sk_dst_cache = dst;
1155 dst_release(old_dst);
1156}
1157
1158static inline void
1159sk_dst_set(struct sock *sk, struct dst_entry *dst)
1160{
1161 write_lock(&sk->sk_dst_lock);
1162 __sk_dst_set(sk, dst);
1163 write_unlock(&sk->sk_dst_lock);
1164}
1165
1166static inline void
1167__sk_dst_reset(struct sock *sk)
1168{
1169 struct dst_entry *old_dst;
1170
1171 old_dst = sk->sk_dst_cache;
1172 sk->sk_dst_cache = NULL;
1173 dst_release(old_dst);
1174}
1175
1176static inline void
1177sk_dst_reset(struct sock *sk)
1178{
1179 write_lock(&sk->sk_dst_lock);
1180 __sk_dst_reset(sk);
1181 write_unlock(&sk->sk_dst_lock);
1182}
1183
Denis Vlasenkof0088a52006-03-28 01:08:21 -08001184extern struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
Denis Vlasenkof0088a52006-03-28 01:08:21 -08001186extern struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
Herbert Xubcd76112006-06-30 13:36:35 -07001188static inline int sk_can_gso(const struct sock *sk)
1189{
1190 return net_gso_ok(sk->sk_route_caps, sk->sk_gso_type);
1191}
1192
Andi Kleen99580892007-04-20 17:12:43 -07001193extern void sk_setup_caps(struct sock *sk, struct dst_entry *dst);
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -07001194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195static inline int skb_copy_to_page(struct sock *sk, char __user *from,
1196 struct sk_buff *skb, struct page *page,
1197 int off, int copy)
1198{
1199 if (skb->ip_summed == CHECKSUM_NONE) {
1200 int err = 0;
Al Viro50842052006-11-14 21:36:34 -08001201 __wsum csum = csum_and_copy_from_user(from,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 page_address(page) + off,
1203 copy, 0, &err);
1204 if (err)
1205 return err;
1206 skb->csum = csum_block_add(skb->csum, csum, skb->len);
1207 } else if (copy_from_user(page_address(page) + off, from, copy))
1208 return -EFAULT;
1209
1210 skb->len += copy;
1211 skb->data_len += copy;
1212 skb->truesize += copy;
1213 sk->sk_wmem_queued += copy;
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001214 sk_mem_charge(sk, copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 return 0;
1216}
1217
Eric Dumazetc5640392009-06-16 10:12:03 +00001218/**
1219 * sk_wmem_alloc_get - returns write allocations
1220 * @sk: socket
1221 *
1222 * Returns sk_wmem_alloc minus initial offset of one
1223 */
1224static inline int sk_wmem_alloc_get(const struct sock *sk)
1225{
1226 return atomic_read(&sk->sk_wmem_alloc) - 1;
1227}
1228
1229/**
1230 * sk_rmem_alloc_get - returns read allocations
1231 * @sk: socket
1232 *
1233 * Returns sk_rmem_alloc
1234 */
1235static inline int sk_rmem_alloc_get(const struct sock *sk)
1236{
1237 return atomic_read(&sk->sk_rmem_alloc);
1238}
1239
1240/**
1241 * sk_has_allocations - check if allocations are outstanding
1242 * @sk: socket
1243 *
1244 * Returns true if socket has write or read allocations
1245 */
1246static inline int sk_has_allocations(const struct sock *sk)
1247{
1248 return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
1249}
1250
Jiri Olsaa57de0b2009-07-08 12:09:13 +00001251/**
1252 * sk_has_sleeper - check if there are any waiting processes
1253 * @sk: socket
1254 *
1255 * Returns true if socket has waiting processes
1256 *
1257 * The purpose of the sk_has_sleeper and sock_poll_wait is to wrap the memory
1258 * barrier call. They were added due to the race found within the tcp code.
1259 *
1260 * Consider following tcp code paths:
1261 *
1262 * CPU1 CPU2
1263 *
1264 * sys_select receive packet
1265 * ... ...
1266 * __add_wait_queue update tp->rcv_nxt
1267 * ... ...
1268 * tp->rcv_nxt check sock_def_readable
1269 * ... {
1270 * schedule ...
1271 * if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1272 * wake_up_interruptible(sk->sk_sleep)
1273 * ...
1274 * }
1275 *
1276 * The race for tcp fires when the __add_wait_queue changes done by CPU1 stay
1277 * in its cache, and so does the tp->rcv_nxt update on CPU2 side. The CPU1
1278 * could then endup calling schedule and sleep forever if there are no more
1279 * data on the socket.
Jiri Olsaad462762009-07-08 12:10:31 +00001280 *
1281 * The sk_has_sleeper is always called right after a call to read_lock, so we
1282 * can use smp_mb__after_lock barrier.
Jiri Olsaa57de0b2009-07-08 12:09:13 +00001283 */
1284static inline int sk_has_sleeper(struct sock *sk)
1285{
1286 /*
1287 * We need to be sure we are in sync with the
1288 * add_wait_queue modifications to the wait queue.
1289 *
1290 * This memory barrier is paired in the sock_poll_wait.
1291 */
Jiri Olsaad462762009-07-08 12:10:31 +00001292 smp_mb__after_lock();
Jiri Olsaa57de0b2009-07-08 12:09:13 +00001293 return sk->sk_sleep && waitqueue_active(sk->sk_sleep);
1294}
1295
1296/**
1297 * sock_poll_wait - place memory barrier behind the poll_wait call.
1298 * @filp: file
1299 * @wait_address: socket wait queue
1300 * @p: poll_table
1301 *
1302 * See the comments in the sk_has_sleeper function.
1303 */
1304static inline void sock_poll_wait(struct file *filp,
1305 wait_queue_head_t *wait_address, poll_table *p)
1306{
1307 if (p && wait_address) {
1308 poll_wait(filp, wait_address, p);
1309 /*
1310 * We need to be sure we are in sync with the
1311 * socket flags modification.
1312 *
1313 * This memory barrier is paired in the sk_has_sleeper.
1314 */
1315 smp_mb();
1316 }
1317}
1318
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319/*
1320 * Queue a received datagram if it will fit. Stream and sequenced
1321 * protocols can't normally use this as they need to fit buffers in
1322 * and play with them.
1323 *
1324 * Inlined as it's very short and called for pretty much every
1325 * packet ever received.
1326 */
1327
1328static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
1329{
Herbert Xud55d87f2009-06-22 02:25:25 +00001330 skb_orphan(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 skb->sk = sk;
1332 skb->destructor = sock_wfree;
Eric Dumazet2b85a342009-06-11 02:55:43 -07001333 /*
1334 * We used to take a refcount on sk, but following operation
1335 * is enough to guarantee sk_free() wont free this sock until
1336 * all in-flight packets are completed
1337 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 atomic_add(skb->truesize, &sk->sk_wmem_alloc);
1339}
1340
1341static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
1342{
Herbert Xud55d87f2009-06-22 02:25:25 +00001343 skb_orphan(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 skb->sk = sk;
1345 skb->destructor = sock_rfree;
1346 atomic_add(skb->truesize, &sk->sk_rmem_alloc);
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001347 sk_mem_charge(sk, skb->truesize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348}
1349
1350extern void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1351 unsigned long expires);
1352
1353extern void sk_stop_timer(struct sock *sk, struct timer_list* timer);
1354
Denis Vlasenkof0088a52006-03-28 01:08:21 -08001355extern int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
1357static inline int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
1358{
1359 /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
1360 number of warnings when compiling with -W --ANK
1361 */
1362 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
1363 (unsigned)sk->sk_rcvbuf)
1364 return -ENOMEM;
1365 skb_set_owner_r(skb, sk);
1366 skb_queue_tail(&sk->sk_error_queue, skb);
1367 if (!sock_flag(sk, SOCK_DEAD))
1368 sk->sk_data_ready(sk, skb->len);
1369 return 0;
1370}
1371
1372/*
1373 * Recover an error report and clear atomically
1374 */
1375
1376static inline int sock_error(struct sock *sk)
1377{
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -08001378 int err;
1379 if (likely(!sk->sk_err))
1380 return 0;
1381 err = xchg(&sk->sk_err, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 return -err;
1383}
1384
1385static inline unsigned long sock_wspace(struct sock *sk)
1386{
1387 int amt = 0;
1388
1389 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
1390 amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1391 if (amt < 0)
1392 amt = 0;
1393 }
1394 return amt;
1395}
1396
1397static inline void sk_wake_async(struct sock *sk, int how, int band)
1398{
1399 if (sk->sk_socket && sk->sk_socket->fasync_list)
1400 sock_wake_async(sk->sk_socket, how, band);
1401}
1402
1403#define SOCK_MIN_SNDBUF 2048
1404#define SOCK_MIN_RCVBUF 256
1405
1406static inline void sk_stream_moderate_sndbuf(struct sock *sk)
1407{
1408 if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
Eric Dumazet8df09ea2007-12-21 03:07:41 -08001409 sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 sk->sk_sndbuf = max(sk->sk_sndbuf, SOCK_MIN_SNDBUF);
1411 }
1412}
1413
Pavel Emelyanovdf97c702007-11-29 21:22:33 +11001414struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415
1416static inline struct page *sk_stream_alloc_page(struct sock *sk)
1417{
1418 struct page *page = NULL;
1419
Herbert Xuef015782005-09-01 17:48:59 -07001420 page = alloc_pages(sk->sk_allocation, 0);
1421 if (!page) {
Pavel Emelyanov5c52ba12008-07-16 20:28:10 -07001422 sk->sk_prot->enter_memory_pressure(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 sk_stream_moderate_sndbuf(sk);
1424 }
1425 return page;
1426}
1427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428/*
1429 * Default write policy as shown to user space via poll/select/SIGIO
1430 */
1431static inline int sock_writeable(const struct sock *sk)
1432{
Eric Dumazet8df09ea2007-12-21 03:07:41 -08001433 return atomic_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434}
1435
Al Virodd0fc662005-10-07 07:46:04 +01001436static inline gfp_t gfp_any(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437{
Andrew Morton99709372009-02-12 16:43:17 -08001438 return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439}
1440
1441static inline long sock_rcvtimeo(const struct sock *sk, int noblock)
1442{
1443 return noblock ? 0 : sk->sk_rcvtimeo;
1444}
1445
1446static inline long sock_sndtimeo(const struct sock *sk, int noblock)
1447{
1448 return noblock ? 0 : sk->sk_sndtimeo;
1449}
1450
1451static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
1452{
1453 return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;
1454}
1455
1456/* Alas, with timeout socket operations are not restartable.
1457 * Compare this to poll().
1458 */
1459static inline int sock_intr_errno(long timeo)
1460{
1461 return timeo == MAX_SCHEDULE_TIMEOUT ? -ERESTARTSYS : -EINTR;
1462}
1463
Eric Dumazet92f37fd2007-03-25 22:14:49 -07001464extern void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
1465 struct sk_buff *skb);
1466
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467static __inline__ void
1468sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
1469{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001470 ktime_t kt = skb->tstamp;
Patrick Ohly20d49472009-02-12 05:03:38 +00001471 struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001472
Patrick Ohly20d49472009-02-12 05:03:38 +00001473 /*
1474 * generate control messages if
1475 * - receive time stamping in software requested (SOCK_RCVTSTAMP
1476 * or SOCK_TIMESTAMPING_RX_SOFTWARE)
1477 * - software time stamp available and wanted
1478 * (SOCK_TIMESTAMPING_SOFTWARE)
1479 * - hardware time stamps available and wanted
1480 * (SOCK_TIMESTAMPING_SYS_HARDWARE or
1481 * SOCK_TIMESTAMPING_RAW_HARDWARE)
1482 */
1483 if (sock_flag(sk, SOCK_RCVTSTAMP) ||
1484 sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE) ||
1485 (kt.tv64 && sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) ||
1486 (hwtstamps->hwtstamp.tv64 &&
1487 sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE)) ||
1488 (hwtstamps->syststamp.tv64 &&
1489 sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE)))
Eric Dumazet92f37fd2007-03-25 22:14:49 -07001490 __sock_recv_timestamp(msg, sk, skb);
1491 else
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001492 sk->sk_stamp = kt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493}
1494
1495/**
Patrick Ohly20d49472009-02-12 05:03:38 +00001496 * sock_tx_timestamp - checks whether the outgoing packet is to be time stamped
1497 * @msg: outgoing packet
1498 * @sk: socket sending this packet
1499 * @shtx: filled with instructions for time stamping
1500 *
1501 * Currently only depends on SOCK_TIMESTAMPING* flags. Returns error code if
1502 * parameters are invalid.
1503 */
1504extern int sock_tx_timestamp(struct msghdr *msg,
1505 struct sock *sk,
1506 union skb_shared_tx *shtx);
1507
1508
1509/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 * sk_eat_skb - Release a skb if it is no longer needed
Pavel Pisa4dc3b162005-05-01 08:59:25 -07001511 * @sk: socket to eat this skb from
1512 * @skb: socket buffer to eat
Randy Dunlapf4b8ea72006-06-22 16:00:11 -07001513 * @copied_early: flag indicating whether DMA operations copied this data early
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 *
1515 * This routine must be called with interrupts disabled or with the socket
1516 * locked so that the sk_buff queue operation is ok.
1517*/
Chris Leech624d1162006-05-23 18:01:28 -07001518#ifdef CONFIG_NET_DMA
1519static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
1520{
1521 __skb_unlink(skb, &sk->sk_receive_queue);
1522 if (!copied_early)
1523 __kfree_skb(skb);
1524 else
1525 __skb_queue_tail(&sk->sk_async_wait_queue, skb);
1526}
1527#else
1528static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529{
1530 __skb_unlink(skb, &sk->sk_receive_queue);
1531 __kfree_skb(skb);
1532}
Chris Leech624d1162006-05-23 18:01:28 -07001533#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001535static inline
1536struct net *sock_net(const struct sock *sk)
1537{
1538#ifdef CONFIG_NET_NS
1539 return sk->sk_net;
1540#else
1541 return &init_net;
1542#endif
1543}
1544
1545static inline
Denis V. Lunevf5aa23f2008-03-26 00:48:17 -07001546void sock_net_set(struct sock *sk, struct net *net)
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001547{
1548#ifdef CONFIG_NET_NS
1549 sk->sk_net = net;
1550#endif
1551}
1552
Denis V. Lunevedf02082008-02-29 11:18:32 -08001553/*
1554 * Kernel sockets, f.e. rtnl or icmp_socket, are a part of a namespace.
1555 * They should not hold a referrence to a namespace in order to allow
1556 * to stop it.
1557 * Sockets after sk_change_net should be released using sk_release_kernel
1558 */
1559static inline void sk_change_net(struct sock *sk, struct net *net)
1560{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001561 put_net(sock_net(sk));
Denis V. Lunev65a18ec2008-04-16 01:59:46 -07001562 sock_net_set(sk, hold_net(net));
Denis V. Lunevedf02082008-02-29 11:18:32 -08001563}
1564
KOVACS Krisztian23542612008-10-07 12:41:01 -07001565static inline struct sock *skb_steal_sock(struct sk_buff *skb)
1566{
1567 if (unlikely(skb->sk)) {
1568 struct sock *sk = skb->sk;
1569
1570 skb->destructor = NULL;
1571 skb->sk = NULL;
1572 return sk;
1573 }
1574 return NULL;
1575}
1576
Patrick Ohly20d49472009-02-12 05:03:38 +00001577extern void sock_enable_timestamp(struct sock *sk, int flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578extern int sock_get_timestamp(struct sock *, struct timeval __user *);
Eric Dumazetae40eb12007-03-18 17:33:16 -07001579extern int sock_get_timestampns(struct sock *, struct timespec __user *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
1581/*
1582 * Enable debug/info messages
1583 */
Stephen Hemmingera2a316f2007-03-08 20:41:08 -08001584extern int net_msg_warn;
1585#define NETDEBUG(fmt, args...) \
1586 do { if (net_msg_warn) printk(fmt,##args); } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587
Stephen Hemmingera2a316f2007-03-08 20:41:08 -08001588#define LIMIT_NETDEBUG(fmt, args...) \
1589 do { if (net_msg_warn && net_ratelimit()) printk(fmt,##args); } while(0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591extern __u32 sysctl_wmem_max;
1592extern __u32 sysctl_rmem_max;
1593
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001594extern void sk_init(void);
1595
David S. Miller6baf1f42005-09-05 18:14:11 -07001596extern int sysctl_optmem_max;
1597
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001598extern __u32 sysctl_wmem_default;
1599extern __u32 sysctl_rmem_default;
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -03001600
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601#endif /* _SOCK_H */