Line data Source code
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 : * Definitions for the AF_INET socket handler.
7 : *
8 : * Version: @(#)sock.h 1.0.4 05/13/93
9 : *
10 : * Authors: Ross Biro
11 : * 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 :
43 : #include <linux/kernel.h>
44 : #include <linux/list.h>
45 : #include <linux/list_nulls.h>
46 : #include <linux/timer.h>
47 : #include <linux/cache.h>
48 : #include <linux/module.h>
49 : #include <linux/lockdep.h>
50 : #include <linux/netdevice.h>
51 : #include <linux/skbuff.h> /* struct sk_buff */
52 : #include <linux/mm.h>
53 : #include <linux/security.h>
54 :
55 : #include <linux/filter.h>
56 : #include <linux/rculist_nulls.h>
57 : #include <linux/poll.h>
58 :
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
75 : /* Validate arguments and do nothing */
76 : static void inline int __attribute__ ((format (printf, 2, 3)))
77 : SOCK_DEBUG(struct sock *sk, const char *msg, ...)
78 : {
79 : }
80 : #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 : */
86 : typedef struct {
87 : spinlock_t slock;
88 : int owned;
89 : wait_queue_head_t wq;
90 : /*
91 1 : * We express the mutex-alike socket_lock semantics
92 4 : * 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
99 2 : } socket_lock_t;
100 :
101 : struct sock;
102 : struct proto;
103 : struct net;
104 :
105 : /**
106 : * struct sock_common - minimal network layer representation of sockets
107 : * @skc_node: main hash linkage for various protocol lookup tables
108 : * @skc_nulls_node: main hash linkage for TCP/UDP/UDP-Lite protocol
109 : * @skc_refcnt: reference count
110 : * @skc_tx_queue_mapping: tx queue number for this connection
111 : * @skc_hash: hash value used with various protocol lookup tables
112 : * @skc_u16hashes: two u16 hash values used by UDP lookup tables
113 : * @skc_family: network address family
114 : * @skc_state: Connection state
115 : * @skc_reuse: %SO_REUSEADDR setting
116 : * @skc_bound_dev_if: bound device index if != 0
117 : * @skc_bind_node: bind hash linkage for various protocol lookup tables
118 : * @skc_portaddr_node: second hash linkage for UDP/UDP-Lite protocol
119 : * @skc_prot: protocol handlers inside a network family
120 : * @skc_net: reference to the network namespace of this socket
121 : *
122 : * This is the minimal network layer representation of sockets, the header
123 : * for struct sock and struct inet_timewait_sock.
124 : */
125 : struct sock_common {
126 : /*
127 : * first fields are not copied in sock_copy()
128 : */
129 : union {
130 : struct hlist_node skc_node;
131 : struct hlist_nulls_node skc_nulls_node;
132 : };
133 : atomic_t skc_refcnt;
134 : int skc_tx_queue_mapping;
135 :
136 : union {
137 : unsigned int skc_hash;
138 : __u16 skc_u16hashes[2];
139 : };
140 : unsigned short skc_family;
141 : volatile unsigned char skc_state;
142 : unsigned char skc_reuse;
143 : int skc_bound_dev_if;
144 : union {
145 : struct hlist_node skc_bind_node;
146 : struct hlist_nulls_node skc_portaddr_node;
147 : };
148 : struct proto *skc_prot;
149 : #ifdef CONFIG_NET_NS
150 2 : struct net *skc_net;
151 : #endif
152 : };
153 :
154 : /**
155 : * struct sock - network layer representation of sockets
156 : * @__sk_common: shared layout with inet_timewait_sock
157 : * @sk_shutdown: mask of %SEND_SHUTDOWN and/or %RCV_SHUTDOWN
158 : * @sk_userlocks: %SO_SNDBUF and %SO_RCVBUF settings
159 : * @sk_lock: synchronizer
160 : * @sk_rcvbuf: size of receive buffer in bytes
161 : * @sk_sleep: sock wait queue
162 : * @sk_dst_cache: destination cache
163 : * @sk_dst_lock: destination cache lock
164 : * @sk_policy: flow policy
165 : * @sk_rmem_alloc: receive queue bytes committed
166 : * @sk_receive_queue: incoming packets
167 : * @sk_wmem_alloc: transmit queue bytes committed
168 : * @sk_write_queue: Packet sending queue
169 : * @sk_async_wait_queue: DMA copied packets
170 : * @sk_omem_alloc: "o" is "option" or "other"
171 : * @sk_wmem_queued: persistent queue size
172 : * @sk_forward_alloc: space allocated forward
173 : * @sk_allocation: allocation mode
174 : * @sk_sndbuf: size of send buffer in bytes
175 : * @sk_flags: %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
176 : * %SO_OOBINLINE settings, %SO_TIMESTAMPING settings
177 : * @sk_no_check: %SO_NO_CHECK setting, wether or not checkup packets
178 : * @sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)
179 : * @sk_gso_type: GSO type (e.g. %SKB_GSO_TCPV4)
180 : * @sk_gso_max_size: Maximum GSO segment size to build
181 : * @sk_lingertime: %SO_LINGER l_linger setting
182 : * @sk_backlog: always used with the per-socket spinlock held
183 : * @sk_callback_lock: used with the callbacks in the end of this struct
184 : * @sk_error_queue: rarely used
185 : * @sk_prot_creator: sk_prot of original sock creator (see ipv6_setsockopt,
186 : * IPV6_ADDRFORM for instance)
187 : * @sk_err: last error
188 : * @sk_err_soft: errors that don't cause failure but are the cause of a
189 : * persistent failure not just 'timed out'
190 : * @sk_drops: raw/udp drops counter
191 : * @sk_ack_backlog: current listen backlog
192 : * @sk_max_ack_backlog: listen backlog set in listen()
193 : * @sk_priority: %SO_PRIORITY setting
194 : * @sk_type: socket type (%SOCK_STREAM, etc)
195 : * @sk_protocol: which protocol this socket belongs in this network family
196 : * @sk_peercred: %SO_PEERCRED setting
197 : * @sk_rcvlowat: %SO_RCVLOWAT setting
198 : * @sk_rcvtimeo: %SO_RCVTIMEO setting
199 : * @sk_sndtimeo: %SO_SNDTIMEO setting
200 : * @sk_filter: socket filtering instructions
201 : * @sk_protinfo: private area, net family specific, when not using slab
202 : * @sk_timer: sock cleanup timer
203 : * @sk_stamp: time stamp of last packet received
204 : * @sk_socket: Identd and reporting IO signals
205 : * @sk_user_data: RPC layer private data
206 : * @sk_sndmsg_page: cached page for sendmsg
207 : * @sk_sndmsg_off: cached offset for sendmsg
208 : * @sk_send_head: front of stuff to transmit
209 : * @sk_security: used by security modules
210 : * @sk_mark: generic packet mark
211 : * @sk_write_pending: a write to stream socket waits to start
212 : * @sk_state_change: callback to indicate change in the state of the sock
213 : * @sk_data_ready: callback to indicate there is data to be processed
214 : * @sk_write_space: callback to indicate there is bf sending space available
215 : * @sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)
216 : * @sk_backlog_rcv: callback to process the backlog
217 : * @sk_destruct: called at sock freeing time, i.e. when all refcnt == 0
218 : */
219 : struct sock {
220 : /*
221 : * Now struct inet_timewait_sock also uses sock_common, so please just
222 : * don't add nothing before this first member (__sk_common) --acme
223 : */
224 : struct sock_common __sk_common;
225 : #define sk_node __sk_common.skc_node
226 : #define sk_nulls_node __sk_common.skc_nulls_node
227 : #define sk_refcnt __sk_common.skc_refcnt
228 : #define sk_tx_queue_mapping __sk_common.skc_tx_queue_mapping
229 :
230 : #define sk_copy_start __sk_common.skc_hash
231 : #define sk_hash __sk_common.skc_hash
232 : #define sk_family __sk_common.skc_family
233 : #define sk_state __sk_common.skc_state
234 : #define sk_reuse __sk_common.skc_reuse
235 : #define sk_bound_dev_if __sk_common.skc_bound_dev_if
236 : #define sk_bind_node __sk_common.skc_bind_node
237 : #define sk_prot __sk_common.skc_prot
238 : #define sk_net __sk_common.skc_net
239 : kmemcheck_bitfield_begin(flags);
240 : unsigned int sk_shutdown : 2,
241 : sk_no_check : 2,
242 : sk_userlocks : 4,
243 : sk_protocol : 8,
244 : sk_type : 16;
245 : kmemcheck_bitfield_end(flags);
246 : int sk_rcvbuf;
247 : socket_lock_t sk_lock;
248 : /*
249 : * The backlog queue is special, it is always used with
250 : * the per-socket spinlock held and requires low latency
251 : * access. Therefore we special case it's implementation.
252 : */
253 : struct {
254 : struct sk_buff *head;
255 : struct sk_buff *tail;
256 : int len;
257 : int limit;
258 : } sk_backlog;
259 : wait_queue_head_t *sk_sleep;
260 : struct dst_entry *sk_dst_cache;
261 : #ifdef CONFIG_XFRM
262 : struct xfrm_policy *sk_policy[2];
263 : #endif
264 : rwlock_t sk_dst_lock;
265 : atomic_t sk_rmem_alloc;
266 : atomic_t sk_wmem_alloc;
267 : atomic_t sk_omem_alloc;
268 : int sk_sndbuf;
269 : struct sk_buff_head sk_receive_queue;
270 : struct sk_buff_head sk_write_queue;
271 : #ifdef CONFIG_NET_DMA
272 : struct sk_buff_head sk_async_wait_queue;
273 : #endif
274 : int sk_wmem_queued;
275 : int sk_forward_alloc;
276 : gfp_t sk_allocation;
277 : int sk_route_caps;
278 : int sk_gso_type;
279 : unsigned int sk_gso_max_size;
280 : int sk_rcvlowat;
281 : unsigned long sk_flags;
282 : unsigned long sk_lingertime;
283 : struct sk_buff_head sk_error_queue;
284 : struct proto *sk_prot_creator;
285 : rwlock_t sk_callback_lock;
286 : int sk_err,
287 : sk_err_soft;
288 : atomic_t sk_drops;
289 : unsigned short sk_ack_backlog;
290 : unsigned short sk_max_ack_backlog;
291 : __u32 sk_priority;
292 : struct ucred sk_peercred;
293 : long sk_rcvtimeo;
294 : long sk_sndtimeo;
295 : struct sk_filter *sk_filter;
296 : void *sk_protinfo;
297 : struct timer_list sk_timer;
298 : ktime_t sk_stamp;
299 : struct socket *sk_socket;
300 : void *sk_user_data;
301 : struct page *sk_sndmsg_page;
302 : struct sk_buff *sk_send_head;
303 : __u32 sk_sndmsg_off;
304 : int sk_write_pending;
305 : #ifdef CONFIG_SECURITY
306 : void *sk_security;
307 : #endif
308 : __u32 sk_mark;
309 : /* XXX 4 bytes hole on 64 bit */
310 : void (*sk_state_change)(struct sock *sk);
311 : void (*sk_data_ready)(struct sock *sk, int bytes);
312 : void (*sk_write_space)(struct sock *sk);
313 : void (*sk_error_report)(struct sock *sk);
314 : int (*sk_backlog_rcv)(struct sock *sk,
315 : struct sk_buff *skb);
316 : void (*sk_destruct)(struct sock *sk);
317 : };
318 :
319 : /*
320 : * Hashed lists helper routines
321 : */
322 : static inline struct sock *__sk_head(const struct hlist_head *head)
323 : {
324 4 : return hlist_entry(head->first, struct sock, sk_node);
325 : }
326 :
327 : static inline struct sock *sk_head(const struct hlist_head *head)
328 : {
329 11 : return hlist_empty(head) ? NULL : __sk_head(head);
330 1 : }
331 1 :
332 : static inline struct sock *__sk_nulls_head(const struct hlist_nulls_head *head)
333 : {
334 : return hlist_nulls_entry(head->first, struct sock, sk_nulls_node);
335 : }
336 :
337 : static inline struct sock *sk_nulls_head(const struct hlist_nulls_head *head)
338 : {
339 : return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
340 : }
341 :
342 : static inline struct sock *sk_next(const struct sock *sk)
343 : {
344 2 : return sk->sk_node.next ?
345 6 : hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
346 : }
347 :
348 : static inline struct sock *sk_nulls_next(const struct sock *sk)
349 : {
350 : return (!is_a_nulls(sk->sk_nulls_node.next)) ?
351 : hlist_nulls_entry(sk->sk_nulls_node.next,
352 : struct sock, sk_nulls_node) :
353 : NULL;
354 : }
355 :
356 : static inline int sk_unhashed(const struct sock *sk)
357 : {
358 4 : return hlist_unhashed(&sk->sk_node);
359 : }
360 :
361 : static inline int sk_hashed(const struct sock *sk)
362 : {
363 4 : return !sk_unhashed(sk);
364 : }
365 :
366 : static __inline__ void sk_node_init(struct hlist_node *node)
367 : {
368 1 : node->pprev = NULL;
369 1 : }
370 :
371 : static __inline__ void sk_nulls_node_init(struct hlist_nulls_node *node)
372 : {
373 : node->pprev = NULL;
374 : }
375 :
376 : static __inline__ void __sk_del_node(struct sock *sk)
377 : {
378 2 : __hlist_del(&sk->sk_node);
379 1 : }
380 :
381 : static __inline__ int __sk_del_node_init(struct sock *sk)
382 : {
383 5 : if (sk_hashed(sk)) {
384 2 : __sk_del_node(sk);
385 2 : sk_node_init(&sk->sk_node);
386 1 : return 1;
387 : }
388 1 : return 0;
389 : }
390 :
391 : /* Grab socket reference count. This operation is valid only
392 : when sk is ALREADY grabbed f.e. it is found in hash table
393 : or a list and the lookup is made under lock preventing hash table
394 : modifications.
395 : */
396 :
397 : static inline void sock_hold(struct sock *sk)
398 : {
399 12 : atomic_inc(&sk->sk_refcnt);
400 6 : }
401 :
402 : /* Ungrab socket in the context, which assumes that socket refcnt
403 : cannot hit zero, f.e. it is true in context of any socketcall.
404 : */
405 : static inline void __sock_put(struct sock *sk)
406 : {
407 8 : atomic_dec(&sk->sk_refcnt);
408 4 : }
409 :
410 : static __inline__ int sk_del_node_init(struct sock *sk)
411 : {
412 5 : int rc = __sk_del_node_init(sk);
413 1 :
414 3 : if (rc) {
415 1 : /* paranoid for a while -acme */
416 11 : WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
417 2 : __sock_put(sk);
418 : }
419 2 : return rc;
420 : }
421 :
422 : static __inline__ int __sk_nulls_del_node_init_rcu(struct sock *sk)
423 : {
424 : if (sk_hashed(sk)) {
425 : hlist_nulls_del_init_rcu(&sk->sk_nulls_node);
426 : return 1;
427 : }
428 : return 0;
429 : }
430 :
431 : static __inline__ int sk_nulls_del_node_init_rcu(struct sock *sk)
432 : {
433 : int rc = __sk_nulls_del_node_init_rcu(sk);
434 :
435 : if (rc) {
436 : /* paranoid for a while -acme */
437 : WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
438 : __sock_put(sk);
439 : }
440 : return rc;
441 : }
442 :
443 : static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list)
444 : {
445 4 : hlist_add_head(&sk->sk_node, list);
446 2 : }
447 :
448 : static __inline__ void sk_add_node(struct sock *sk, struct hlist_head *list)
449 : {
450 4 : sock_hold(sk);
451 4 : __sk_add_node(sk, list);
452 2 : }
453 :
454 : static __inline__ void __sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
455 : {
456 : hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
457 : }
458 :
459 : static __inline__ void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
460 : {
461 : sock_hold(sk);
462 : __sk_nulls_add_node_rcu(sk, list);
463 : }
464 :
465 : static __inline__ void __sk_del_bind_node(struct sock *sk)
466 : {
467 : __hlist_del(&sk->sk_bind_node);
468 : }
469 :
470 : static __inline__ void sk_add_bind_node(struct sock *sk,
471 : struct hlist_head *list)
472 : {
473 : hlist_add_head(&sk->sk_bind_node, list);
474 : }
475 1 :
476 : #define sk_for_each(__sk, node, list) \
477 : hlist_for_each_entry(__sk, node, list, sk_node)
478 : #define sk_nulls_for_each(__sk, node, list) \
479 : hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)
480 : #define sk_nulls_for_each_rcu(__sk, node, list) \
481 : hlist_nulls_for_each_entry_rcu(__sk, node, list, sk_nulls_node)
482 : #define sk_for_each_from(__sk, node) \
483 : if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
484 : hlist_for_each_entry_from(__sk, node, sk_node)
485 : #define sk_nulls_for_each_from(__sk, node) \
486 : if (__sk && ({ node = &(__sk)->sk_nulls_node; 1; })) \
487 : hlist_nulls_for_each_entry_from(__sk, node, sk_nulls_node)
488 : #define sk_for_each_continue(__sk, node) \
489 : if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
490 : hlist_for_each_entry_continue(__sk, node, sk_node)
491 : #define sk_for_each_safe(__sk, node, tmp, list) \
492 : hlist_for_each_entry_safe(__sk, node, tmp, list, sk_node)
493 : #define sk_for_each_bound(__sk, node, list) \
494 : hlist_for_each_entry(__sk, node, list, sk_bind_node)
495 :
496 : /* Sock flags */
497 : enum sock_flags {
498 : SOCK_DEAD,
499 : SOCK_DONE,
500 : SOCK_URGINLINE,
501 : SOCK_KEEPOPEN,
502 : SOCK_LINGER,
503 : SOCK_DESTROY,
504 : SOCK_BROADCAST,
505 : SOCK_TIMESTAMP,
506 : SOCK_ZAPPED,
507 : SOCK_USE_WRITE_QUEUE, /* whether to call sk->sk_write_space in sock_wfree */
508 : SOCK_DBG, /* %SO_DEBUG setting */
509 : SOCK_RCVTSTAMP, /* %SO_TIMESTAMP setting */
510 : SOCK_RCVTSTAMPNS, /* %SO_TIMESTAMPNS setting */
511 : SOCK_LOCALROUTE, /* route locally only, %SO_DONTROUTE setting */
512 : SOCK_QUEUE_SHRUNK, /* write queue has been shrunk recently */
513 : SOCK_TIMESTAMPING_TX_HARDWARE, /* %SOF_TIMESTAMPING_TX_HARDWARE */
514 : SOCK_TIMESTAMPING_TX_SOFTWARE, /* %SOF_TIMESTAMPING_TX_SOFTWARE */
515 : SOCK_TIMESTAMPING_RX_HARDWARE, /* %SOF_TIMESTAMPING_RX_HARDWARE */
516 : SOCK_TIMESTAMPING_RX_SOFTWARE, /* %SOF_TIMESTAMPING_RX_SOFTWARE */
517 : SOCK_TIMESTAMPING_SOFTWARE, /* %SOF_TIMESTAMPING_SOFTWARE */
518 : SOCK_TIMESTAMPING_RAW_HARDWARE, /* %SOF_TIMESTAMPING_RAW_HARDWARE */
519 : SOCK_TIMESTAMPING_SYS_HARDWARE, /* %SOF_TIMESTAMPING_SYS_HARDWARE */
520 : SOCK_FASYNC, /* fasync() active */
521 : SOCK_RXQ_OVFL,
522 : };
523 :
524 : static inline void sock_copy_flags(struct sock *nsk, struct sock *osk)
525 : {
526 : nsk->sk_flags = osk->sk_flags;
527 : }
528 :
529 : static inline void sock_set_flag(struct sock *sk, enum sock_flags flag)
530 : {
531 2 : __set_bit(flag, &sk->sk_flags);
532 1 : }
533 :
534 : static inline void sock_reset_flag(struct sock *sk, enum sock_flags flag)
535 : {
536 : __clear_bit(flag, &sk->sk_flags);
537 : }
538 :
539 : static inline int sock_flag(struct sock *sk, enum sock_flags flag)
540 : {
541 12 : return test_bit(flag, &sk->sk_flags);
542 : }
543 :
544 : static inline void sk_acceptq_removed(struct sock *sk)
545 : {
546 : sk->sk_ack_backlog--;
547 : }
548 :
549 : static inline void sk_acceptq_added(struct sock *sk)
550 : {
551 : sk->sk_ack_backlog++;
552 : }
553 :
554 : static inline int sk_acceptq_is_full(struct sock *sk)
555 : {
556 : return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
557 : }
558 :
559 : /*
560 : * Compute minimal free write space needed to queue new packets.
561 : */
562 : static inline int sk_stream_min_wspace(struct sock *sk)
563 : {
564 : return sk->sk_wmem_queued >> 1;
565 : }
566 :
567 : static inline int sk_stream_wspace(struct sock *sk)
568 : {
569 : return sk->sk_sndbuf - sk->sk_wmem_queued;
570 : }
571 :
572 : extern void sk_stream_write_space(struct sock *sk);
573 :
574 : static inline int sk_stream_memory_free(struct sock *sk)
575 : {
576 : return sk->sk_wmem_queued < sk->sk_sndbuf;
577 : }
578 :
579 : /* OOB backlog add */
580 : static inline void __sk_add_backlog(struct sock *sk, struct sk_buff *skb)
581 : {
582 : if (!sk->sk_backlog.tail) {
583 : sk->sk_backlog.head = sk->sk_backlog.tail = skb;
584 : } else {
585 : sk->sk_backlog.tail->next = skb;
586 : sk->sk_backlog.tail = skb;
587 : }
588 : skb->next = NULL;
589 : }
590 :
591 : /* The per-socket spinlock must be held here. */
592 : static inline __must_check int sk_add_backlog(struct sock *sk, struct sk_buff *skb)
593 : {
594 : if (sk->sk_backlog.len >= max(sk->sk_backlog.limit, sk->sk_rcvbuf << 1))
595 : return -ENOBUFS;
596 :
597 : __sk_add_backlog(sk, skb);
598 : sk->sk_backlog.len += skb->truesize;
599 : return 0;
600 : }
601 :
602 : static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
603 : {
604 : return sk->sk_backlog_rcv(sk, skb);
605 : }
606 :
607 : #define sk_wait_event(__sk, __timeo, __condition) \
608 : ({ int __rc; \
609 : release_sock(__sk); \
610 : __rc = __condition; \
611 : if (!__rc) { \
612 : *(__timeo) = schedule_timeout(*(__timeo)); \
613 : } \
614 : lock_sock(__sk); \
615 : __rc = __condition; \
616 : __rc; \
617 : })
618 :
619 : extern int sk_stream_wait_connect(struct sock *sk, long *timeo_p);
620 : extern int sk_stream_wait_memory(struct sock *sk, long *timeo_p);
621 : extern void sk_stream_wait_close(struct sock *sk, long timeo_p);
622 : extern int sk_stream_error(struct sock *sk, int flags, int err);
623 : extern void sk_stream_kill_queues(struct sock *sk);
624 :
625 : extern int sk_wait_data(struct sock *sk, long *timeo);
626 1 :
627 1 : struct request_sock_ops;
628 1 : struct timewait_sock_ops;
629 1 : struct inet_hashinfo;
630 3 : struct raw_hashinfo;
631 :
632 : /* Networking protocol blocks we attach to sockets.
633 : * socket layer -> transport layer interface
634 : * transport -> network interface is defined by struct inet_proto
635 : */
636 : struct proto {
637 : void (*close)(struct sock *sk,
638 : long timeout);
639 : int (*connect)(struct sock *sk,
640 : struct sockaddr *uaddr,
641 : int addr_len);
642 : int (*disconnect)(struct sock *sk, int flags);
643 :
644 : struct sock * (*accept) (struct sock *sk, int flags, int *err);
645 :
646 : int (*ioctl)(struct sock *sk, int cmd,
647 : unsigned long arg);
648 : int (*init)(struct sock *sk);
649 : void (*destroy)(struct sock *sk);
650 : void (*shutdown)(struct sock *sk, int how);
651 : int (*setsockopt)(struct sock *sk, int level,
652 : int optname, char __user *optval,
653 : unsigned int optlen);
654 : int (*getsockopt)(struct sock *sk, int level,
655 : int optname, char __user *optval,
656 : int __user *option);
657 : #ifdef CONFIG_COMPAT
658 : int (*compat_setsockopt)(struct sock *sk,
659 : int level,
660 : int optname, char __user *optval,
661 : unsigned int optlen);
662 : int (*compat_getsockopt)(struct sock *sk,
663 : int level,
664 : int optname, char __user *optval,
665 : int __user *option);
666 : #endif
667 : int (*sendmsg)(struct kiocb *iocb, struct sock *sk,
668 : struct msghdr *msg, size_t len);
669 : int (*recvmsg)(struct kiocb *iocb, struct sock *sk,
670 : struct msghdr *msg,
671 : size_t len, int noblock, int flags,
672 : int *addr_len);
673 : int (*sendpage)(struct sock *sk, struct page *page,
674 : int offset, size_t size, int flags);
675 : int (*bind)(struct sock *sk,
676 : struct sockaddr *uaddr, int addr_len);
677 :
678 : int (*backlog_rcv) (struct sock *sk,
679 : struct sk_buff *skb);
680 :
681 : /* Keeping track of sk's, looking them up, and port selection methods. */
682 : void (*hash)(struct sock *sk);
683 : void (*unhash)(struct sock *sk);
684 : void (*rehash)(struct sock *sk);
685 : int (*get_port)(struct sock *sk, unsigned short snum);
686 :
687 : /* Keeping track of sockets in use */
688 : #ifdef CONFIG_PROC_FS
689 : unsigned int inuse_idx;
690 : #endif
691 :
692 : /* Memory pressure */
693 : void (*enter_memory_pressure)(struct sock *sk);
694 : atomic_t *memory_allocated; /* Current allocated memory. */
695 : struct percpu_counter *sockets_allocated; /* Current number of sockets. */
696 : /*
697 : * Pressure flag: try to collapse.
698 : * Technical note: it is used by multiple contexts non atomically.
699 : * All the __sk_mem_schedule() is of this nature: accounting
700 : * is strict, actions are advisory and have some latency.
701 : */
702 : int *memory_pressure;
703 : int *sysctl_mem;
704 : int *sysctl_wmem;
705 : int *sysctl_rmem;
706 : int max_header;
707 :
708 : struct kmem_cache *slab;
709 : unsigned int obj_size;
710 : int slab_flags;
711 :
712 : struct percpu_counter *orphan_count;
713 :
714 : struct request_sock_ops *rsk_prot;
715 : struct timewait_sock_ops *twsk_prot;
716 :
717 : union {
718 : struct inet_hashinfo *hashinfo;
719 : struct udp_table *udp_table;
720 : struct raw_hashinfo *raw_hash;
721 : } h;
722 :
723 : struct module *owner;
724 :
725 : char name[32];
726 :
727 : struct list_head node;
728 : #ifdef SOCK_REFCNT_DEBUG
729 : atomic_t socks;
730 : #endif
731 : };
732 :
733 : extern int proto_register(struct proto *prot, int alloc_slab);
734 : extern void proto_unregister(struct proto *prot);
735 :
736 : #ifdef SOCK_REFCNT_DEBUG
737 : static inline void sk_refcnt_debug_inc(struct sock *sk)
738 : {
739 : atomic_inc(&sk->sk_prot->socks);
740 : }
741 :
742 : static inline void sk_refcnt_debug_dec(struct sock *sk)
743 : {
744 : atomic_dec(&sk->sk_prot->socks);
745 : printk(KERN_DEBUG "%s socket %p released, %d are still alive\n",
746 : sk->sk_prot->name, sk, atomic_read(&sk->sk_prot->socks));
747 : }
748 :
749 : static inline void sk_refcnt_debug_release(const struct sock *sk)
750 : {
751 : if (atomic_read(&sk->sk_refcnt) != 1)
752 : printk(KERN_DEBUG "Destruction of the %s socket %p delayed, refcnt=%d\n",
753 : sk->sk_prot->name, sk, atomic_read(&sk->sk_refcnt));
754 : }
755 : #else /* SOCK_REFCNT_DEBUG */
756 : #define sk_refcnt_debug_inc(sk) do { } while (0)
757 : #define sk_refcnt_debug_dec(sk) do { } while (0)
758 : #define sk_refcnt_debug_release(sk) do { } while (0)
759 : #endif /* SOCK_REFCNT_DEBUG */
760 :
761 :
762 : #ifdef CONFIG_PROC_FS
763 : /* Called with local bh disabled */
764 : extern void sock_prot_inuse_add(struct net *net, struct proto *prot, int inc);
765 : extern int sock_prot_inuse_get(struct net *net, struct proto *proto);
766 : #else
767 : static void inline sock_prot_inuse_add(struct net *net, struct proto *prot,
768 : int inc)
769 : {
770 : }
771 : #endif
772 :
773 :
774 : /* With per-bucket locks this operation is not-atomic, so that
775 : * this version is not worse.
776 : */
777 : static inline void __sk_prot_rehash(struct sock *sk)
778 : {
779 : sk->sk_prot->unhash(sk);
780 : sk->sk_prot->hash(sk);
781 : }
782 :
783 : /* About 10 seconds */
784 : #define SOCK_DESTROY_TIME (10*HZ)
785 :
786 : /* Sockets 0-1023 can't be bound to unless you are superuser */
787 : #define PROT_SOCK 1024
788 :
789 : #define SHUTDOWN_MASK 3
790 : #define RCV_SHUTDOWN 1
791 : #define SEND_SHUTDOWN 2
792 :
793 : #define SOCK_SNDBUF_LOCK 1
794 : #define SOCK_RCVBUF_LOCK 2
795 : #define SOCK_BINDADDR_LOCK 4
796 : #define SOCK_BINDPORT_LOCK 8
797 :
798 : /* sock_iocb: used to kick off async processing of socket ios */
799 : struct sock_iocb {
800 : struct list_head list;
801 :
802 : int flags;
803 : int size;
804 : struct socket *sock;
805 : struct sock *sk;
806 : struct scm_cookie *scm;
807 : struct msghdr *msg, async_msg;
808 : struct kiocb *kiocb;
809 : };
810 :
811 : static inline struct sock_iocb *kiocb_to_siocb(struct kiocb *iocb)
812 : {
813 : return (struct sock_iocb *)iocb->private;
814 : }
815 :
816 : static inline struct kiocb *siocb_to_kiocb(struct sock_iocb *si)
817 : {
818 : return si->kiocb;
819 : }
820 :
821 : struct socket_alloc {
822 : struct socket socket;
823 : struct inode vfs_inode;
824 : };
825 :
826 : static inline struct socket *SOCKET_I(struct inode *inode)
827 : {
828 : return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
829 : }
830 :
831 : static inline struct inode *SOCK_INODE(struct socket *socket)
832 : {
833 : return &container_of(socket, struct socket_alloc, socket)->vfs_inode;
834 : }
835 :
836 : /*
837 : * Functions for memory accounting
838 : */
839 : extern int __sk_mem_schedule(struct sock *sk, int size, int kind);
840 : extern void __sk_mem_reclaim(struct sock *sk);
841 :
842 : #define SK_MEM_QUANTUM ((int)PAGE_SIZE)
843 : #define SK_MEM_QUANTUM_SHIFT ilog2(SK_MEM_QUANTUM)
844 : #define SK_MEM_SEND 0
845 : #define SK_MEM_RECV 1
846 :
847 : static inline int sk_mem_pages(int amt)
848 : {
849 : return (amt + SK_MEM_QUANTUM - 1) >> SK_MEM_QUANTUM_SHIFT;
850 : }
851 :
852 : static inline int sk_has_account(struct sock *sk)
853 : {
854 : /* return true if protocol supports memory accounting */
855 0 : return !!sk->sk_prot->memory_allocated;
856 : }
857 :
858 : static inline int sk_wmem_schedule(struct sock *sk, int size)
859 : {
860 : if (!sk_has_account(sk))
861 : return 1;
862 : return size <= sk->sk_forward_alloc ||
863 : __sk_mem_schedule(sk, size, SK_MEM_SEND);
864 : }
865 :
866 : static inline int sk_rmem_schedule(struct sock *sk, int size)
867 : {
868 : if (!sk_has_account(sk))
869 : return 1;
870 : return size <= sk->sk_forward_alloc ||
871 : __sk_mem_schedule(sk, size, SK_MEM_RECV);
872 : }
873 :
874 : static inline void sk_mem_reclaim(struct sock *sk)
875 : {
876 : if (!sk_has_account(sk))
877 : return;
878 : if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
879 : __sk_mem_reclaim(sk);
880 : }
881 :
882 : static inline void sk_mem_reclaim_partial(struct sock *sk)
883 : {
884 : if (!sk_has_account(sk))
885 : return;
886 : if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
887 : __sk_mem_reclaim(sk);
888 : }
889 :
890 : static inline void sk_mem_charge(struct sock *sk, int size)
891 : {
892 0 : if (!sk_has_account(sk))
893 0 : return;
894 0 : sk->sk_forward_alloc -= size;
895 0 : }
896 :
897 : static inline void sk_mem_uncharge(struct sock *sk, int size)
898 : {
899 : if (!sk_has_account(sk))
900 : return;
901 : sk->sk_forward_alloc += size;
902 : }
903 :
904 : static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
905 : {
906 : sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
907 : sk->sk_wmem_queued -= skb->truesize;
908 : sk_mem_uncharge(sk, skb->truesize);
909 : __kfree_skb(skb);
910 : }
911 :
912 : /* Used by processes to "lock" a socket state, so that
913 : * interrupts and bottom half handlers won't change it
914 : * from under us. It essentially blocks any incoming
915 : * packets, so that we won't get any new data or any
916 : * packets that change the state of the socket.
917 : *
918 : * While locked, BH processing will add new packets to
919 : * the backlog queue. This queue is processed by the
920 : * owner of the socket lock right before it is released.
921 : *
922 : * Since ~2.3.5 it is also exclusive sleep lock serializing
923 : * accesses from user process context.
924 : */
925 : #define sock_owned_by_user(sk) ((sk)->sk_lock.owned)
926 :
927 : /*
928 : * Macro so as to not evaluate some arguments when
929 : * lockdep is not enabled.
930 : *
931 : * Mark both the sk_lock and the sk_lock.slock as a
932 : * per-address-family lock class.
933 : */
934 : #define sock_lock_init_class_and_name(sk, sname, skey, name, key) \
935 : do { \
936 : sk->sk_lock.owned = 0; \
937 : init_waitqueue_head(&sk->sk_lock.wq); \
938 : spin_lock_init(&(sk)->sk_lock.slock); \
939 : debug_check_no_locks_freed((void *)&(sk)->sk_lock, \
940 : sizeof((sk)->sk_lock)); \
941 : lockdep_set_class_and_name(&(sk)->sk_lock.slock, \
942 : (skey), (sname)); \
943 : lockdep_init_map(&(sk)->sk_lock.dep_map, (name), (key), 0); \
944 : } while (0)
945 :
946 : extern void lock_sock_nested(struct sock *sk, int subclass);
947 :
948 : static inline void lock_sock(struct sock *sk)
949 : {
950 1 : lock_sock_nested(sk, 0);
951 1 : }
952 :
953 : extern void release_sock(struct sock *sk);
954 :
955 : /* BH context may only use the following locking interface. */
956 : #define bh_lock_sock(__sk) spin_lock(&((__sk)->sk_lock.slock))
957 : #define bh_lock_sock_nested(__sk) \
958 : spin_lock_nested(&((__sk)->sk_lock.slock), \
959 : SINGLE_DEPTH_NESTING)
960 : #define bh_unlock_sock(__sk) spin_unlock(&((__sk)->sk_lock.slock))
961 :
962 : extern struct sock *sk_alloc(struct net *net, int family,
963 : gfp_t priority,
964 : struct proto *prot);
965 : extern void sk_free(struct sock *sk);
966 : extern void sk_release_kernel(struct sock *sk);
967 : extern struct sock *sk_clone(const struct sock *sk,
968 : const gfp_t priority);
969 :
970 : extern struct sk_buff *sock_wmalloc(struct sock *sk,
971 : unsigned long size, int force,
972 : gfp_t priority);
973 : extern struct sk_buff *sock_rmalloc(struct sock *sk,
974 : unsigned long size, int force,
975 : gfp_t priority);
976 : extern void sock_wfree(struct sk_buff *skb);
977 : extern void sock_rfree(struct sk_buff *skb);
978 :
979 : extern int sock_setsockopt(struct socket *sock, int level,
980 : int op, char __user *optval,
981 : unsigned int optlen);
982 :
983 : extern int sock_getsockopt(struct socket *sock, int level,
984 : int op, char __user *optval,
985 : int __user *optlen);
986 : extern struct sk_buff *sock_alloc_send_skb(struct sock *sk,
987 : unsigned long size,
988 : int noblock,
989 : int *errcode);
990 : extern struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
991 : unsigned long header_len,
992 : unsigned long data_len,
993 : int noblock,
994 : int *errcode);
995 : extern void *sock_kmalloc(struct sock *sk, int size,
996 : gfp_t priority);
997 : extern void sock_kfree_s(struct sock *sk, void *mem, int size);
998 : extern void sk_send_sigurg(struct sock *sk);
999 :
1000 : /*
1001 : * Functions to fill in entries in struct proto_ops when a protocol
1002 : * does not implement a particular function.
1003 : */
1004 : extern int sock_no_bind(struct socket *,
1005 : struct sockaddr *, int);
1006 : extern int sock_no_connect(struct socket *,
1007 : struct sockaddr *, int, int);
1008 : extern int sock_no_socketpair(struct socket *,
1009 : struct socket *);
1010 : extern int sock_no_accept(struct socket *,
1011 : struct socket *, int);
1012 : extern int sock_no_getname(struct socket *,
1013 : struct sockaddr *, int *, int);
1014 : extern unsigned int sock_no_poll(struct file *, struct socket *,
1015 : struct poll_table_struct *);
1016 : extern int sock_no_ioctl(struct socket *, unsigned int,
1017 : unsigned long);
1018 : extern int sock_no_listen(struct socket *, int);
1019 : extern int sock_no_shutdown(struct socket *, int);
1020 : extern int sock_no_getsockopt(struct socket *, int , int,
1021 : char __user *, int __user *);
1022 : extern int sock_no_setsockopt(struct socket *, int, int,
1023 : char __user *, unsigned int);
1024 : extern int sock_no_sendmsg(struct kiocb *, struct socket *,
1025 : struct msghdr *, size_t);
1026 : extern int sock_no_recvmsg(struct kiocb *, struct socket *,
1027 : struct msghdr *, size_t, int);
1028 : extern int sock_no_mmap(struct file *file,
1029 : struct socket *sock,
1030 : struct vm_area_struct *vma);
1031 : extern ssize_t sock_no_sendpage(struct socket *sock,
1032 : struct page *page,
1033 : int offset, size_t size,
1034 : int flags);
1035 :
1036 : /*
1037 : * Functions to fill in entries in struct proto_ops when a protocol
1038 : * uses the inet style.
1039 : */
1040 : extern int sock_common_getsockopt(struct socket *sock, int level, int optname,
1041 : char __user *optval, int __user *optlen);
1042 : extern int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1043 : struct msghdr *msg, size_t size, int flags);
1044 : extern int sock_common_setsockopt(struct socket *sock, int level, int optname,
1045 : char __user *optval, unsigned int optlen);
1046 : extern int compat_sock_common_getsockopt(struct socket *sock, int level,
1047 : int optname, char __user *optval, int __user *optlen);
1048 : extern int compat_sock_common_setsockopt(struct socket *sock, int level,
1049 : int optname, char __user *optval, unsigned int optlen);
1050 :
1051 : extern void sk_common_release(struct sock *sk);
1052 :
1053 : /*
1054 : * Default socket callbacks and setup code
1055 : */
1056 :
1057 : /* Initialise core socket variables */
1058 : extern void sock_init_data(struct socket *sock, struct sock *sk);
1059 :
1060 : /**
1061 : * sk_filter_release: Release a socket filter
1062 : * @fp: filter to remove
1063 : *
1064 : * Remove a filter from a socket and release its resources.
1065 : */
1066 :
1067 : static inline void sk_filter_release(struct sk_filter *fp)
1068 : {
1069 : if (atomic_dec_and_test(&fp->refcnt))
1070 : kfree(fp);
1071 : }
1072 :
1073 : static inline void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
1074 : {
1075 : unsigned int size = sk_filter_len(fp);
1076 :
1077 : atomic_sub(size, &sk->sk_omem_alloc);
1078 : sk_filter_release(fp);
1079 : }
1080 :
1081 : static inline void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
1082 : {
1083 : atomic_inc(&fp->refcnt);
1084 : atomic_add(sk_filter_len(fp), &sk->sk_omem_alloc);
1085 : }
1086 :
1087 : /*
1088 : * Socket reference counting postulates.
1089 : *
1090 : * * Each user of socket SHOULD hold a reference count.
1091 : * * Each access point to socket (an hash table bucket, reference from a list,
1092 : * running timer, skb in flight MUST hold a reference count.
1093 : * * When reference count hits 0, it means it will never increase back.
1094 : * * When reference count hits 0, it means that no references from
1095 : * outside exist to this socket and current process on current CPU
1096 : * is last user and may/should destroy this socket.
1097 : * * sk_free is called from any context: process, BH, IRQ. When
1098 : * it is called, socket has no references from outside -> sk_free
1099 : * may release descendant resources allocated by the socket, but
1100 : * to the time when it is called, socket is NOT referenced by any
1101 : * hash tables, lists etc.
1102 : * * Packets, delivered from outside (from network or from another process)
1103 : * and enqueued on receive/error queues SHOULD NOT grab reference count,
1104 : * when they sit in queue. Otherwise, packets will leak to hole, when
1105 : * socket is looked up by one cpu and unhasing is made by another CPU.
1106 : * It is true for udp/raw, netlink (leak to receive and error queues), tcp
1107 : * (leak to backlog). Packet socket does all the processing inside
1108 : * BR_NETPROTO_LOCK, so that it has not this race condition. UNIX sockets
1109 : * use separate SMP lock, so that they are prone too.
1110 : */
1111 :
1112 : /* Ungrab socket and destroy it, if it was the last reference. */
1113 : static inline void sock_put(struct sock *sk)
1114 : {
1115 5 : if (atomic_dec_and_test(&sk->sk_refcnt))
1116 1 : sk_free(sk);
1117 1 : }
1118 :
1119 : extern int sk_receive_skb(struct sock *sk, struct sk_buff *skb,
1120 : const int nested);
1121 :
1122 : static inline void sk_tx_queue_set(struct sock *sk, int tx_queue)
1123 : {
1124 : sk->sk_tx_queue_mapping = tx_queue;
1125 : }
1126 :
1127 : static inline void sk_tx_queue_clear(struct sock *sk)
1128 : {
1129 1 : sk->sk_tx_queue_mapping = -1;
1130 1 : }
1131 :
1132 : static inline int sk_tx_queue_get(const struct sock *sk)
1133 : {
1134 : return sk ? sk->sk_tx_queue_mapping : -1;
1135 : }
1136 :
1137 : static inline void sk_set_socket(struct sock *sk, struct socket *sock)
1138 : {
1139 2 : sk_tx_queue_clear(sk);
1140 1 : sk->sk_socket = sock;
1141 1 : }
1142 :
1143 : /* Detach socket from process context.
1144 : * Announce socket dead, detach it from wait queue and inode.
1145 : * Note that parent inode held reference count on this struct sock,
1146 : * we do not release it in this function, because protocol
1147 : * probably wants some additional cleanups or even continuing
1148 : * to work with this socket (TCP).
1149 : */
1150 : static inline void sock_orphan(struct sock *sk)
1151 : {
1152 1 : write_lock_bh(&sk->sk_callback_lock);
1153 2 : sock_set_flag(sk, SOCK_DEAD);
1154 2 : sk_set_socket(sk, NULL);
1155 1 : sk->sk_sleep = NULL;
1156 1 : write_unlock_bh(&sk->sk_callback_lock);
1157 1 : }
1158 :
1159 : static inline void sock_graft(struct sock *sk, struct socket *parent)
1160 : {
1161 : write_lock_bh(&sk->sk_callback_lock);
1162 : sk->sk_sleep = &parent->wait;
1163 : parent->sk = sk;
1164 : sk_set_socket(sk, parent);
1165 : security_sock_graft(sk, parent);
1166 : write_unlock_bh(&sk->sk_callback_lock);
1167 : }
1168 :
1169 : extern int sock_i_uid(struct sock *sk);
1170 : extern unsigned long sock_i_ino(struct sock *sk);
1171 :
1172 : static inline struct dst_entry *
1173 : __sk_dst_get(struct sock *sk)
1174 : {
1175 : return sk->sk_dst_cache;
1176 : }
1177 :
1178 : static inline struct dst_entry *
1179 : sk_dst_get(struct sock *sk)
1180 : {
1181 : struct dst_entry *dst;
1182 :
1183 : read_lock(&sk->sk_dst_lock);
1184 : dst = sk->sk_dst_cache;
1185 : if (dst)
1186 : dst_hold(dst);
1187 : read_unlock(&sk->sk_dst_lock);
1188 : return dst;
1189 : }
1190 :
1191 : static inline void
1192 : __sk_dst_set(struct sock *sk, struct dst_entry *dst)
1193 : {
1194 : struct dst_entry *old_dst;
1195 :
1196 : sk_tx_queue_clear(sk);
1197 : old_dst = sk->sk_dst_cache;
1198 : sk->sk_dst_cache = dst;
1199 : dst_release(old_dst);
1200 : }
1201 :
1202 : static inline void
1203 : sk_dst_set(struct sock *sk, struct dst_entry *dst)
1204 : {
1205 : write_lock(&sk->sk_dst_lock);
1206 : __sk_dst_set(sk, dst);
1207 : write_unlock(&sk->sk_dst_lock);
1208 : }
1209 :
1210 : static inline void
1211 : __sk_dst_reset(struct sock *sk)
1212 : {
1213 : struct dst_entry *old_dst;
1214 :
1215 : sk_tx_queue_clear(sk);
1216 : old_dst = sk->sk_dst_cache;
1217 : sk->sk_dst_cache = NULL;
1218 : dst_release(old_dst);
1219 : }
1220 :
1221 : static inline void
1222 : sk_dst_reset(struct sock *sk)
1223 : {
1224 : write_lock(&sk->sk_dst_lock);
1225 : __sk_dst_reset(sk);
1226 : write_unlock(&sk->sk_dst_lock);
1227 : }
1228 :
1229 : extern struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie);
1230 :
1231 : extern struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie);
1232 :
1233 : static inline int sk_can_gso(const struct sock *sk)
1234 : {
1235 : return net_gso_ok(sk->sk_route_caps, sk->sk_gso_type);
1236 : }
1237 :
1238 : extern void sk_setup_caps(struct sock *sk, struct dst_entry *dst);
1239 :
1240 : static inline int skb_copy_to_page(struct sock *sk, char __user *from,
1241 : struct sk_buff *skb, struct page *page,
1242 : int off, int copy)
1243 : {
1244 : if (skb->ip_summed == CHECKSUM_NONE) {
1245 : int err = 0;
1246 : __wsum csum = csum_and_copy_from_user(from,
1247 : page_address(page) + off,
1248 : copy, 0, &err);
1249 : if (err)
1250 : return err;
1251 : skb->csum = csum_block_add(skb->csum, csum, skb->len);
1252 : } else if (copy_from_user(page_address(page) + off, from, copy))
1253 : return -EFAULT;
1254 :
1255 : skb->len += copy;
1256 : skb->data_len += copy;
1257 : skb->truesize += copy;
1258 : sk->sk_wmem_queued += copy;
1259 : sk_mem_charge(sk, copy);
1260 : return 0;
1261 : }
1262 :
1263 : /**
1264 : * sk_wmem_alloc_get - returns write allocations
1265 : * @sk: socket
1266 : *
1267 : * Returns sk_wmem_alloc minus initial offset of one
1268 : */
1269 : static inline int sk_wmem_alloc_get(const struct sock *sk)
1270 : {
1271 4 : return atomic_read(&sk->sk_wmem_alloc) - 1;
1272 : }
1273 :
1274 : /**
1275 : * sk_rmem_alloc_get - returns read allocations
1276 : * @sk: socket
1277 : *
1278 : * Returns sk_rmem_alloc
1279 : */
1280 : static inline int sk_rmem_alloc_get(const struct sock *sk)
1281 : {
1282 : return atomic_read(&sk->sk_rmem_alloc);
1283 : }
1284 :
1285 : /**
1286 : * sk_has_allocations - check if allocations are outstanding
1287 : * @sk: socket
1288 : *
1289 : * Returns true if socket has write or read allocations
1290 : */
1291 : static inline int sk_has_allocations(const struct sock *sk)
1292 : {
1293 : return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
1294 : }
1295 :
1296 : /**
1297 : * sk_has_sleeper - check if there are any waiting processes
1298 : * @sk: socket
1299 : *
1300 : * Returns true if socket has waiting processes
1301 : *
1302 : * The purpose of the sk_has_sleeper and sock_poll_wait is to wrap the memory
1303 : * barrier call. They were added due to the race found within the tcp code.
1304 : *
1305 : * Consider following tcp code paths:
1306 : *
1307 : * CPU1 CPU2
1308 : *
1309 : * sys_select receive packet
1310 : * ... ...
1311 : * __add_wait_queue update tp->rcv_nxt
1312 : * ... ...
1313 : * tp->rcv_nxt check sock_def_readable
1314 : * ... {
1315 : * schedule ...
1316 : * if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1317 : * wake_up_interruptible(sk->sk_sleep)
1318 : * ...
1319 : * }
1320 : *
1321 : * The race for tcp fires when the __add_wait_queue changes done by CPU1 stay
1322 : * in its cache, and so does the tp->rcv_nxt update on CPU2 side. The CPU1
1323 : * could then endup calling schedule and sleep forever if there are no more
1324 : * data on the socket.
1325 : *
1326 : * The sk_has_sleeper is always called right after a call to read_lock, so we
1327 : * can use smp_mb__after_lock barrier.
1328 : */
1329 : static inline int sk_has_sleeper(struct sock *sk)
1330 : {
1331 : /*
1332 : * We need to be sure we are in sync with the
1333 : * add_wait_queue modifications to the wait queue.
1334 : *
1335 : * This memory barrier is paired in the sock_poll_wait.
1336 : */
1337 : smp_mb__after_lock();
1338 : return sk->sk_sleep && waitqueue_active(sk->sk_sleep);
1339 : }
1340 :
1341 : /**
1342 : * sock_poll_wait - place memory barrier behind the poll_wait call.
1343 : * @filp: file
1344 : * @wait_address: socket wait queue
1345 : * @p: poll_table
1346 : *
1347 : * See the comments in the sk_has_sleeper function.
1348 : */
1349 : static inline void sock_poll_wait(struct file *filp,
1350 : wait_queue_head_t *wait_address, poll_table *p)
1351 : {
1352 : if (p && wait_address) {
1353 : poll_wait(filp, wait_address, p);
1354 : /*
1355 : * We need to be sure we are in sync with the
1356 : * socket flags modification.
1357 : *
1358 : * This memory barrier is paired in the sk_has_sleeper.
1359 : */
1360 : smp_mb();
1361 : }
1362 : }
1363 :
1364 : /*
1365 : * Queue a received datagram if it will fit. Stream and sequenced
1366 : * protocols can't normally use this as they need to fit buffers in
1367 : * and play with them.
1368 : *
1369 : * Inlined as it's very short and called for pretty much every
1370 : * packet ever received.
1371 : */
1372 :
1373 : static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
1374 : {
1375 : skb_orphan(skb);
1376 : skb->sk = sk;
1377 : skb->destructor = sock_wfree;
1378 : /*
1379 : * We used to take a refcount on sk, but following operation
1380 : * is enough to guarantee sk_free() wont free this sock until
1381 : * all in-flight packets are completed
1382 : */
1383 : atomic_add(skb->truesize, &sk->sk_wmem_alloc);
1384 : }
1385 :
1386 : static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
1387 : {
1388 0 : skb_orphan(skb);
1389 0 : skb->sk = sk;
1390 0 : skb->destructor = sock_rfree;
1391 0 : atomic_add(skb->truesize, &sk->sk_rmem_alloc);
1392 0 : sk_mem_charge(sk, skb->truesize);
1393 0 : }
1394 :
1395 : extern void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1396 : unsigned long expires);
1397 :
1398 : extern void sk_stop_timer(struct sock *sk, struct timer_list* timer);
1399 :
1400 : extern int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
1401 :
1402 : static inline int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
1403 : {
1404 : /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
1405 : number of warnings when compiling with -W --ANK
1406 : */
1407 : if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
1408 : (unsigned)sk->sk_rcvbuf)
1409 : return -ENOMEM;
1410 : skb_set_owner_r(skb, sk);
1411 : skb_queue_tail(&sk->sk_error_queue, skb);
1412 : if (!sock_flag(sk, SOCK_DEAD))
1413 : sk->sk_data_ready(sk, skb->len);
1414 : return 0;
1415 : }
1416 :
1417 : /*
1418 : * Recover an error report and clear atomically
1419 : */
1420 :
1421 : static inline int sock_error(struct sock *sk)
1422 : {
1423 : int err;
1424 : if (likely(!sk->sk_err))
1425 : return 0;
1426 : err = xchg(&sk->sk_err, 0);
1427 : return -err;
1428 : }
1429 :
1430 : static inline unsigned long sock_wspace(struct sock *sk)
1431 : {
1432 : int amt = 0;
1433 :
1434 : if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
1435 : amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1436 : if (amt < 0)
1437 : amt = 0;
1438 : }
1439 : return amt;
1440 : }
1441 :
1442 : static inline void sk_wake_async(struct sock *sk, int how, int band)
1443 : {
1444 : if (sock_flag(sk, SOCK_FASYNC))
1445 : sock_wake_async(sk->sk_socket, how, band);
1446 : }
1447 :
1448 : #define SOCK_MIN_SNDBUF 2048
1449 : #define SOCK_MIN_RCVBUF 256
1450 :
1451 : static inline void sk_stream_moderate_sndbuf(struct sock *sk)
1452 : {
1453 : if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
1454 : sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
1455 : sk->sk_sndbuf = max(sk->sk_sndbuf, SOCK_MIN_SNDBUF);
1456 : }
1457 : }
1458 :
1459 : struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp);
1460 :
1461 : static inline struct page *sk_stream_alloc_page(struct sock *sk)
1462 : {
1463 : struct page *page = NULL;
1464 :
1465 : page = alloc_pages(sk->sk_allocation, 0);
1466 : if (!page) {
1467 : sk->sk_prot->enter_memory_pressure(sk);
1468 : sk_stream_moderate_sndbuf(sk);
1469 : }
1470 : return page;
1471 : }
1472 :
1473 : /*
1474 : * Default write policy as shown to user space via poll/select/SIGIO
1475 : */
1476 : static inline int sock_writeable(const struct sock *sk)
1477 : {
1478 : return atomic_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);
1479 : }
1480 :
1481 : static inline gfp_t gfp_any(void)
1482 : {
1483 : return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
1484 : }
1485 :
1486 : static inline long sock_rcvtimeo(const struct sock *sk, int noblock)
1487 : {
1488 : return noblock ? 0 : sk->sk_rcvtimeo;
1489 : }
1490 :
1491 : static inline long sock_sndtimeo(const struct sock *sk, int noblock)
1492 : {
1493 : return noblock ? 0 : sk->sk_sndtimeo;
1494 : }
1495 :
1496 : static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
1497 : {
1498 : return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;
1499 : }
1500 :
1501 : /* Alas, with timeout socket operations are not restartable.
1502 : * Compare this to poll().
1503 : */
1504 : static inline int sock_intr_errno(long timeo)
1505 : {
1506 : return timeo == MAX_SCHEDULE_TIMEOUT ? -ERESTARTSYS : -EINTR;
1507 : }
1508 :
1509 : extern void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
1510 : struct sk_buff *skb);
1511 :
1512 : static __inline__ void
1513 : sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
1514 : {
1515 : ktime_t kt = skb->tstamp;
1516 : struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
1517 :
1518 : /*
1519 : * generate control messages if
1520 : * - receive time stamping in software requested (SOCK_RCVTSTAMP
1521 : * or SOCK_TIMESTAMPING_RX_SOFTWARE)
1522 : * - software time stamp available and wanted
1523 : * (SOCK_TIMESTAMPING_SOFTWARE)
1524 : * - hardware time stamps available and wanted
1525 : * (SOCK_TIMESTAMPING_SYS_HARDWARE or
1526 : * SOCK_TIMESTAMPING_RAW_HARDWARE)
1527 : */
1528 : if (sock_flag(sk, SOCK_RCVTSTAMP) ||
1529 : sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE) ||
1530 : (kt.tv64 && sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) ||
1531 : (hwtstamps->hwtstamp.tv64 &&
1532 : sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE)) ||
1533 : (hwtstamps->syststamp.tv64 &&
1534 : sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE)))
1535 : __sock_recv_timestamp(msg, sk, skb);
1536 : else
1537 : sk->sk_stamp = kt;
1538 : }
1539 :
1540 : extern void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk, struct sk_buff *skb);
1541 :
1542 : /**
1543 : * sock_tx_timestamp - checks whether the outgoing packet is to be time stamped
1544 : * @msg: outgoing packet
1545 : * @sk: socket sending this packet
1546 : * @shtx: filled with instructions for time stamping
1547 : *
1548 : * Currently only depends on SOCK_TIMESTAMPING* flags. Returns error code if
1549 : * parameters are invalid.
1550 : */
1551 : extern int sock_tx_timestamp(struct msghdr *msg,
1552 : struct sock *sk,
1553 : union skb_shared_tx *shtx);
1554 :
1555 :
1556 : /**
1557 : * sk_eat_skb - Release a skb if it is no longer needed
1558 : * @sk: socket to eat this skb from
1559 : * @skb: socket buffer to eat
1560 : * @copied_early: flag indicating whether DMA operations copied this data early
1561 : *
1562 : * This routine must be called with interrupts disabled or with the socket
1563 : * locked so that the sk_buff queue operation is ok.
1564 : */
1565 : #ifdef CONFIG_NET_DMA
1566 : static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
1567 : {
1568 : __skb_unlink(skb, &sk->sk_receive_queue);
1569 : if (!copied_early)
1570 : __kfree_skb(skb);
1571 : else
1572 : __skb_queue_tail(&sk->sk_async_wait_queue, skb);
1573 : }
1574 : #else
1575 : static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
1576 : {
1577 : __skb_unlink(skb, &sk->sk_receive_queue);
1578 : __kfree_skb(skb);
1579 : }
1580 : #endif
1581 :
1582 : static inline
1583 : struct net *sock_net(const struct sock *sk)
1584 : {
1585 : #ifdef CONFIG_NET_NS
1586 : return sk->sk_net;
1587 : #else
1588 7 : return &init_net;
1589 : #endif
1590 : }
1591 :
1592 : static inline
1593 : void sock_net_set(struct sock *sk, struct net *net)
1594 : {
1595 : #ifdef CONFIG_NET_NS
1596 : sk->sk_net = net;
1597 : #endif
1598 : }
1599 :
1600 : /*
1601 : * Kernel sockets, f.e. rtnl or icmp_socket, are a part of a namespace.
1602 : * They should not hold a referrence to a namespace in order to allow
1603 : * to stop it.
1604 : * Sockets after sk_change_net should be released using sk_release_kernel
1605 : */
1606 : static inline void sk_change_net(struct sock *sk, struct net *net)
1607 : {
1608 : put_net(sock_net(sk));
1609 : sock_net_set(sk, hold_net(net));
1610 : }
1611 :
1612 : static inline struct sock *skb_steal_sock(struct sk_buff *skb)
1613 : {
1614 : if (unlikely(skb->sk)) {
1615 : struct sock *sk = skb->sk;
1616 :
1617 : skb->destructor = NULL;
1618 : skb->sk = NULL;
1619 : return sk;
1620 : }
1621 : return NULL;
1622 : }
1623 :
1624 : extern void sock_enable_timestamp(struct sock *sk, int flag);
1625 : extern int sock_get_timestamp(struct sock *, struct timeval __user *);
1626 : extern int sock_get_timestampns(struct sock *, struct timespec __user *);
1627 :
1628 : /*
1629 : * Enable debug/info messages
1630 : */
1631 : extern int net_msg_warn;
1632 : #define NETDEBUG(fmt, args...) \
1633 : do { if (net_msg_warn) printk(fmt,##args); } while (0)
1634 :
1635 : #define LIMIT_NETDEBUG(fmt, args...) \
1636 : do { if (net_msg_warn && net_ratelimit()) printk(fmt,##args); } while(0)
1637 :
1638 : extern __u32 sysctl_wmem_max;
1639 : extern __u32 sysctl_rmem_max;
1640 :
1641 : extern void sk_init(void);
1642 :
1643 : extern int sysctl_optmem_max;
1644 :
1645 : extern __u32 sysctl_wmem_default;
1646 : extern __u32 sysctl_rmem_default;
1647 1 :
1648 : #endif /* _SOCK_H */
|