1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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>
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
65
66
67
68
69
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
76static void inline int __attribute__ ((format (printf, 2, 3)))
77SOCK_DEBUG(struct sock *sk, const char *msg, ...)
78{
79}
80#endif
81
82
83
84
85
86typedef struct {
87 spinlock_t slock;
88 int owned;
89 wait_queue_head_t wq;
90
91
92
93
94
95
96#ifdef CONFIG_DEBUG_LOCK_ALLOC
97 struct lockdep_map dep_map;
98#endif
99} socket_lock_t;
100
101struct sock;
102struct proto;
103struct net;
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125struct sock_common {
126
127
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 struct net *skc_net;
151#endif
152};
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219struct sock {
220
221
222
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
250
251
252
253 struct {
254 struct sk_buff *head;
255 struct sk_buff *tail;
256 } sk_backlog;
257 wait_queue_head_t *sk_sleep;
258 struct dst_entry *sk_dst_cache;
259#ifdef CONFIG_XFRM
260 struct xfrm_policy *sk_policy[2];
261#endif
262 rwlock_t sk_dst_lock;
263 atomic_t sk_rmem_alloc;
264 atomic_t sk_wmem_alloc;
265 atomic_t sk_omem_alloc;
266 int sk_sndbuf;
267 struct sk_buff_head sk_receive_queue;
268 struct sk_buff_head sk_write_queue;
269#ifdef CONFIG_NET_DMA
270 struct sk_buff_head sk_async_wait_queue;
271#endif
272 int sk_wmem_queued;
273 int sk_forward_alloc;
274 gfp_t sk_allocation;
275 int sk_route_caps;
276 int sk_gso_type;
277 unsigned int sk_gso_max_size;
278 int sk_rcvlowat;
279 unsigned long sk_flags;
280 unsigned long sk_lingertime;
281 struct sk_buff_head sk_error_queue;
282 struct proto *sk_prot_creator;
283 rwlock_t sk_callback_lock;
284 int sk_err,
285 sk_err_soft;
286 atomic_t sk_drops;
287 unsigned short sk_ack_backlog;
288 unsigned short sk_max_ack_backlog;
289 __u32 sk_priority;
290 struct ucred sk_peercred;
291 long sk_rcvtimeo;
292 long sk_sndtimeo;
293 struct sk_filter *sk_filter;
294 void *sk_protinfo;
295 struct timer_list sk_timer;
296 ktime_t sk_stamp;
297 struct socket *sk_socket;
298 void *sk_user_data;
299 struct page *sk_sndmsg_page;
300 struct sk_buff *sk_send_head;
301 __u32 sk_sndmsg_off;
302 int sk_write_pending;
303#ifdef CONFIG_SECURITY
304 void *sk_security;
305#endif
306 __u32 sk_mark;
307
308 void (*sk_state_change)(struct sock *sk);
309 void (*sk_data_ready)(struct sock *sk, int bytes);
310 void (*sk_write_space)(struct sock *sk);
311 void (*sk_error_report)(struct sock *sk);
312 int (*sk_backlog_rcv)(struct sock *sk,
313 struct sk_buff *skb);
314 void (*sk_destruct)(struct sock *sk);
315};
316
317
318
319
320static inline struct sock *__sk_head(const struct hlist_head *head)
321{
322 return hlist_entry(head->first, struct sock, sk_node);
323}
324
325static inline struct sock *sk_head(const struct hlist_head *head)
326{
327 return hlist_empty(head) ? NULL : __sk_head(head);
328}
329
330static inline struct sock *__sk_nulls_head(const struct hlist_nulls_head *head)
331{
332 return hlist_nulls_entry(head->first, struct sock, sk_nulls_node);
333}
334
335static inline struct sock *sk_nulls_head(const struct hlist_nulls_head *head)
336{
337 return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
338}
339
340static inline struct sock *sk_next(const struct sock *sk)
341{
342 return sk->sk_node.next ?
343 hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
344}
345
346static inline struct sock *sk_nulls_next(const struct sock *sk)
347{
348 return (!is_a_nulls(sk->sk_nulls_node.next)) ?
349 hlist_nulls_entry(sk->sk_nulls_node.next,
350 struct sock, sk_nulls_node) :
351 NULL;
352}
353
354static inline int sk_unhashed(const struct sock *sk)
355{
356 return hlist_unhashed(&sk->sk_node);
357}
358
359static inline int sk_hashed(const struct sock *sk)
360{
361 return !sk_unhashed(sk);
362}
363
364static __inline__ void sk_node_init(struct hlist_node *node)
365{
366 node->pprev = NULL;
367}
368
369static __inline__ void sk_nulls_node_init(struct hlist_nulls_node *node)
370{
371 node->pprev = NULL;
372}
373
374static __inline__ void __sk_del_node(struct sock *sk)
375{
376 __hlist_del(&sk->sk_node);
377}
378
379static __inline__ int __sk_del_node_init(struct sock *sk)
380{
381 if (sk_hashed(sk)) {
382 __sk_del_node(sk);
383 sk_node_init(&sk->sk_node);
384 return 1;
385 }
386 return 0;
387}
388
389
390
391
392
393
394
395static inline void sock_hold(struct sock *sk)
396{
397 atomic_inc(&sk->sk_refcnt);
398}
399
400
401
402
403static inline void __sock_put(struct sock *sk)
404{
405 atomic_dec(&sk->sk_refcnt);
406}
407
408static __inline__ int sk_del_node_init(struct sock *sk)
409{
410 int rc = __sk_del_node_init(sk);
411
412 if (rc) {
413
414 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
415 __sock_put(sk);
416 }
417 return rc;
418}
419
420static __inline__ int __sk_nulls_del_node_init_rcu(struct sock *sk)
421{
422 if (sk_hashed(sk)) {
423 hlist_nulls_del_init_rcu(&sk->sk_nulls_node);
424 return 1;
425 }
426 return 0;
427}
428
429static __inline__ int sk_nulls_del_node_init_rcu(struct sock *sk)
430{
431 int rc = __sk_nulls_del_node_init_rcu(sk);
432
433 if (rc) {
434
435 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
436 __sock_put(sk);
437 }
438 return rc;
439}
440
441static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list)
442{
443 hlist_add_head(&sk->sk_node, list);
444}
445
446static __inline__ void sk_add_node(struct sock *sk, struct hlist_head *list)
447{
448 sock_hold(sk);
449 __sk_add_node(sk, list);
450}
451
452static __inline__ void __sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
453{
454 hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
455}
456
457static __inline__ void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
458{
459 sock_hold(sk);
460 __sk_nulls_add_node_rcu(sk, list);
461}
462
463static __inline__ void __sk_del_bind_node(struct sock *sk)
464{
465 __hlist_del(&sk->sk_bind_node);
466}
467
468static __inline__ void sk_add_bind_node(struct sock *sk,
469 struct hlist_head *list)
470{
471 hlist_add_head(&sk->sk_bind_node, list);
472}
473
474#define sk_for_each(__sk, node, list) \
475 hlist_for_each_entry(__sk, node, list, sk_node)
476#define sk_nulls_for_each(__sk, node, list) \
477 hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)
478#define sk_nulls_for_each_rcu(__sk, node, list) \
479 hlist_nulls_for_each_entry_rcu(__sk, node, list, sk_nulls_node)
480#define sk_for_each_from(__sk, node) \
481 if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
482 hlist_for_each_entry_from(__sk, node, sk_node)
483#define sk_nulls_for_each_from(__sk, node) \
484 if (__sk && ({ node = &(__sk)->sk_nulls_node; 1; })) \
485 hlist_nulls_for_each_entry_from(__sk, node, sk_nulls_node)
486#define sk_for_each_continue(__sk, node) \
487 if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
488 hlist_for_each_entry_continue(__sk, node, sk_node)
489#define sk_for_each_safe(__sk, node, tmp, list) \
490 hlist_for_each_entry_safe(__sk, node, tmp, list, sk_node)
491#define sk_for_each_bound(__sk, node, list) \
492 hlist_for_each_entry(__sk, node, list, sk_bind_node)
493
494
495enum sock_flags {
496 SOCK_DEAD,
497 SOCK_DONE,
498 SOCK_URGINLINE,
499 SOCK_KEEPOPEN,
500 SOCK_LINGER,
501 SOCK_DESTROY,
502 SOCK_BROADCAST,
503 SOCK_TIMESTAMP,
504 SOCK_ZAPPED,
505 SOCK_USE_WRITE_QUEUE,
506 SOCK_DBG,
507 SOCK_RCVTSTAMP,
508 SOCK_RCVTSTAMPNS,
509 SOCK_LOCALROUTE,
510 SOCK_QUEUE_SHRUNK,
511 SOCK_TIMESTAMPING_TX_HARDWARE,
512 SOCK_TIMESTAMPING_TX_SOFTWARE,
513 SOCK_TIMESTAMPING_RX_HARDWARE,
514 SOCK_TIMESTAMPING_RX_SOFTWARE,
515 SOCK_TIMESTAMPING_SOFTWARE,
516 SOCK_TIMESTAMPING_RAW_HARDWARE,
517 SOCK_TIMESTAMPING_SYS_HARDWARE,
518 SOCK_FASYNC,
519 SOCK_RXQ_OVFL,
520};
521
522static inline void sock_copy_flags(struct sock *nsk, struct sock *osk)
523{
524 nsk->sk_flags = osk->sk_flags;
525}
526
527static inline void sock_set_flag(struct sock *sk, enum sock_flags flag)
528{
529 __set_bit(flag, &sk->sk_flags);
530}
531
532static inline void sock_reset_flag(struct sock *sk, enum sock_flags flag)
533{
534 __clear_bit(flag, &sk->sk_flags);
535}
536
537static inline int sock_flag(struct sock *sk, enum sock_flags flag)
538{
539 return test_bit(flag, &sk->sk_flags);
540}
541
542static inline void sk_acceptq_removed(struct sock *sk)
543{
544 sk->sk_ack_backlog--;
545}
546
547static inline void sk_acceptq_added(struct sock *sk)
548{
549 sk->sk_ack_backlog++;
550}
551
552static inline int sk_acceptq_is_full(struct sock *sk)
553{
554 return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
555}
556
557
558
559
560static inline int sk_stream_min_wspace(struct sock *sk)
561{
562 return sk->sk_wmem_queued >> 1;
563}
564
565static inline int sk_stream_wspace(struct sock *sk)
566{
567 return sk->sk_sndbuf - sk->sk_wmem_queued;
568}
569
570extern void sk_stream_write_space(struct sock *sk);
571
572static inline int sk_stream_memory_free(struct sock *sk)
573{
574 return sk->sk_wmem_queued < sk->sk_sndbuf;
575}
576
577
578static inline void sk_add_backlog(struct sock *sk, struct sk_buff *skb)
579{
580 if (!sk->sk_backlog.tail) {
581 sk->sk_backlog.head = sk->sk_backlog.tail = skb;
582 } else {
583 sk->sk_backlog.tail->next = skb;
584 sk->sk_backlog.tail = skb;
585 }
586 skb->next = NULL;
587}
588
589static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
590{
591 return sk->sk_backlog_rcv(sk, skb);
592}
593
594#define sk_wait_event(__sk, __timeo, __condition) \
595 ({ int __rc; \
596 release_sock(__sk); \
597 __rc = __condition; \
598 if (!__rc) { \
599 *(__timeo) = schedule_timeout(*(__timeo)); \
600 } \
601 lock_sock(__sk); \
602 __rc = __condition; \
603 __rc; \
604 })
605
606extern int sk_stream_wait_connect(struct sock *sk, long *timeo_p);
607extern int sk_stream_wait_memory(struct sock *sk, long *timeo_p);
608extern void sk_stream_wait_close(struct sock *sk, long timeo_p);
609extern int sk_stream_error(struct sock *sk, int flags, int err);
610extern void sk_stream_kill_queues(struct sock *sk);
611
612extern int sk_wait_data(struct sock *sk, long *timeo);
613
614struct request_sock_ops;
615struct timewait_sock_ops;
616struct inet_hashinfo;
617struct raw_hashinfo;
618
619
620
621
622
623struct proto {
624 void (*close)(struct sock *sk,
625 long timeout);
626 int (*connect)(struct sock *sk,
627 struct sockaddr *uaddr,
628 int addr_len);
629 int (*disconnect)(struct sock *sk, int flags);
630
631 struct sock * (*accept) (struct sock *sk, int flags, int *err);
632
633 int (*ioctl)(struct sock *sk, int cmd,
634 unsigned long arg);
635 int (*init)(struct sock *sk);
636 void (*destroy)(struct sock *sk);
637 void (*shutdown)(struct sock *sk, int how);
638 int (*setsockopt)(struct sock *sk, int level,
639 int optname, char __user *optval,
640 unsigned int optlen);
641 int (*getsockopt)(struct sock *sk, int level,
642 int optname, char __user *optval,
643 int __user *option);
644#ifdef CONFIG_COMPAT
645 int (*compat_setsockopt)(struct sock *sk,
646 int level,
647 int optname, char __user *optval,
648 unsigned int optlen);
649 int (*compat_getsockopt)(struct sock *sk,
650 int level,
651 int optname, char __user *optval,
652 int __user *option);
653#endif
654 int (*sendmsg)(struct kiocb *iocb, struct sock *sk,
655 struct msghdr *msg, size_t len);
656 int (*recvmsg)(struct kiocb *iocb, struct sock *sk,
657 struct msghdr *msg,
658 size_t len, int noblock, int flags,
659 int *addr_len);
660 int (*sendpage)(struct sock *sk, struct page *page,
661 int offset, size_t size, int flags);
662 int (*bind)(struct sock *sk,
663 struct sockaddr *uaddr, int addr_len);
664
665 int (*backlog_rcv) (struct sock *sk,
666 struct sk_buff *skb);
667
668
669 void (*hash)(struct sock *sk);
670 void (*unhash)(struct sock *sk);
671 int (*get_port)(struct sock *sk, unsigned short snum);
672
673
674#ifdef CONFIG_PROC_FS
675 unsigned int inuse_idx;
676#endif
677
678
679 void (*enter_memory_pressure)(struct sock *sk);
680 atomic_t *memory_allocated;
681 struct percpu_counter *sockets_allocated;
682
683
684
685
686
687
688 int *memory_pressure;
689 int *sysctl_mem;
690 int *sysctl_wmem;
691 int *sysctl_rmem;
692 int max_header;
693
694 struct kmem_cache *slab;
695 unsigned int obj_size;
696 int slab_flags;
697
698 struct percpu_counter *orphan_count;
699
700 struct request_sock_ops *rsk_prot;
701 struct timewait_sock_ops *twsk_prot;
702
703 union {
704 struct inet_hashinfo *hashinfo;
705 struct udp_table *udp_table;
706 struct raw_hashinfo *raw_hash;
707 } h;
708
709 struct module *owner;
710
711 char name[32];
712
713 struct list_head node;
714#ifdef SOCK_REFCNT_DEBUG
715 atomic_t socks;
716#endif
717};
718
719extern int proto_register(struct proto *prot, int alloc_slab);
720extern void proto_unregister(struct proto *prot);
721
722#ifdef SOCK_REFCNT_DEBUG
723static inline void sk_refcnt_debug_inc(struct sock *sk)
724{
725 atomic_inc(&sk->sk_prot->socks);
726}
727
728static inline void sk_refcnt_debug_dec(struct sock *sk)
729{
730 atomic_dec(&sk->sk_prot->socks);
731 printk(KERN_DEBUG "%s socket %p released, %d are still alive\n",
732 sk->sk_prot->name, sk, atomic_read(&sk->sk_prot->socks));
733}
734
735static inline void sk_refcnt_debug_release(const struct sock *sk)
736{
737 if (atomic_read(&sk->sk_refcnt) != 1)
738 printk(KERN_DEBUG "Destruction of the %s socket %p delayed, refcnt=%d\n",
739 sk->sk_prot->name, sk, atomic_read(&sk->sk_refcnt));
740}
741#else
742#define sk_refcnt_debug_inc(sk) do { } while (0)
743#define sk_refcnt_debug_dec(sk) do { } while (0)
744#define sk_refcnt_debug_release(sk) do { } while (0)
745#endif
746
747
748#ifdef CONFIG_PROC_FS
749
750extern void sock_prot_inuse_add(struct net *net, struct proto *prot, int inc);
751extern int sock_prot_inuse_get(struct net *net, struct proto *proto);
752#else
753static void inline sock_prot_inuse_add(struct net *net, struct proto *prot,
754 int inc)
755{
756}
757#endif
758
759
760
761
762
763static inline void __sk_prot_rehash(struct sock *sk)
764{
765 sk->sk_prot->unhash(sk);
766 sk->sk_prot->hash(sk);
767}
768
769
770#define SOCK_DESTROY_TIME (10*HZ)
771
772
773#define PROT_SOCK 1024
774
775#define SHUTDOWN_MASK 3
776#define RCV_SHUTDOWN 1
777#define SEND_SHUTDOWN 2
778
779#define SOCK_SNDBUF_LOCK 1
780#define SOCK_RCVBUF_LOCK 2
781#define SOCK_BINDADDR_LOCK 4
782#define SOCK_BINDPORT_LOCK 8
783
784
785struct sock_iocb {
786 struct list_head list;
787
788 int flags;
789 int size;
790 struct socket *sock;
791 struct sock *sk;
792 struct scm_cookie *scm;
793 struct msghdr *msg, async_msg;
794 struct kiocb *kiocb;
795};
796
797static inline struct sock_iocb *kiocb_to_siocb(struct kiocb *iocb)
798{
799 return (struct sock_iocb *)iocb->private;
800}
801
802static inline struct kiocb *siocb_to_kiocb(struct sock_iocb *si)
803{
804 return si->kiocb;
805}
806
807struct socket_alloc {
808 struct socket socket;
809 struct inode vfs_inode;
810};
811
812static inline struct socket *SOCKET_I(struct inode *inode)
813{
814 return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
815}
816
817static inline struct inode *SOCK_INODE(struct socket *socket)
818{
819 return &container_of(socket, struct socket_alloc, socket)->vfs_inode;
820}
821
822
823
824
825extern int __sk_mem_schedule(struct sock *sk, int size, int kind);
826extern void __sk_mem_reclaim(struct sock *sk);
827
828#define SK_MEM_QUANTUM ((int)PAGE_SIZE)
829#define SK_MEM_QUANTUM_SHIFT ilog2(SK_MEM_QUANTUM)
830#define SK_MEM_SEND 0
831#define SK_MEM_RECV 1
832
833static inline int sk_mem_pages(int amt)
834{
835 return (amt + SK_MEM_QUANTUM - 1) >> SK_MEM_QUANTUM_SHIFT;
836}
837
838static inline int sk_has_account(struct sock *sk)
839{
840
841 return !!sk->sk_prot->memory_allocated;
842}
843
844static inline int sk_wmem_schedule(struct sock *sk, int size)
845{
846 if (!sk_has_account(sk))
847 return 1;
848 return size <= sk->sk_forward_alloc ||
849 __sk_mem_schedule(sk, size, SK_MEM_SEND);
850}
851
852static inline int sk_rmem_schedule(struct sock *sk, int size)
853{
854 if (!sk_has_account(sk))
855 return 1;
856 return size <= sk->sk_forward_alloc ||
857 __sk_mem_schedule(sk, size, SK_MEM_RECV);
858}
859
860static inline void sk_mem_reclaim(struct sock *sk)
861{
862 if (!sk_has_account(sk))
863 return;
864 if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
865 __sk_mem_reclaim(sk);
866}
867
868static inline void sk_mem_reclaim_partial(struct sock *sk)
869{
870 if (!sk_has_account(sk))
871 return;
872 if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
873 __sk_mem_reclaim(sk);
874}
875
876static inline void sk_mem_charge(struct sock *sk, int size)
877{
878 if (!sk_has_account(sk))
879 return;
880 sk->sk_forward_alloc -= size;
881}
882
883static inline void sk_mem_uncharge(struct sock *sk, int size)
884{
885 if (!sk_has_account(sk))
886 return;
887 sk->sk_forward_alloc += size;
888}
889
890static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
891{
892 sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
893 sk->sk_wmem_queued -= skb->truesize;
894 sk_mem_uncharge(sk, skb->truesize);
895 __kfree_skb(skb);
896}
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911#define sock_owned_by_user(sk) ((sk)->sk_lock.owned)
912
913
914
915
916
917
918
919
920#define sock_lock_init_class_and_name(sk, sname, skey, name, key) \
921do { \
922 sk->sk_lock.owned = 0; \
923 init_waitqueue_head(&sk->sk_lock.wq); \
924 spin_lock_init(&(sk)->sk_lock.slock); \
925 debug_check_no_locks_freed((void *)&(sk)->sk_lock, \
926 sizeof((sk)->sk_lock)); \
927 lockdep_set_class_and_name(&(sk)->sk_lock.slock, \
928 (skey), (sname)); \
929 lockdep_init_map(&(sk)->sk_lock.dep_map, (name), (key), 0); \
930} while (0)
931
932extern void lock_sock_nested(struct sock *sk, int subclass);
933
934static inline void lock_sock(struct sock *sk)
935{
936 lock_sock_nested(sk, 0);
937}
938
939extern void release_sock(struct sock *sk);
940
941
942#define bh_lock_sock(__sk) spin_lock(&((__sk)->sk_lock.slock))
943#define bh_lock_sock_nested(__sk) \
944 spin_lock_nested(&((__sk)->sk_lock.slock), \
945 SINGLE_DEPTH_NESTING)
946#define bh_unlock_sock(__sk) spin_unlock(&((__sk)->sk_lock.slock))
947
948extern struct sock *sk_alloc(struct net *net, int family,
949 gfp_t priority,
950 struct proto *prot);
951extern void sk_free(struct sock *sk);
952extern void sk_release_kernel(struct sock *sk);
953extern struct sock *sk_clone(const struct sock *sk,
954 const gfp_t priority);
955
956extern struct sk_buff *sock_wmalloc(struct sock *sk,
957 unsigned long size, int force,
958 gfp_t priority);
959extern struct sk_buff *sock_rmalloc(struct sock *sk,
960 unsigned long size, int force,
961 gfp_t priority);
962extern void sock_wfree(struct sk_buff *skb);
963extern void sock_rfree(struct sk_buff *skb);
964
965extern int sock_setsockopt(struct socket *sock, int level,
966 int op, char __user *optval,
967 unsigned int optlen);
968
969extern int sock_getsockopt(struct socket *sock, int level,
970 int op, char __user *optval,
971 int __user *optlen);
972extern struct sk_buff *sock_alloc_send_skb(struct sock *sk,
973 unsigned long size,
974 int noblock,
975 int *errcode);
976extern struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
977 unsigned long header_len,
978 unsigned long data_len,
979 int noblock,
980 int *errcode);
981extern void *sock_kmalloc(struct sock *sk, int size,
982 gfp_t priority);
983extern void sock_kfree_s(struct sock *sk, void *mem, int size);
984extern void sk_send_sigurg(struct sock *sk);
985
986
987
988
989
990extern int sock_no_bind(struct socket *,
991 struct sockaddr *, int);
992extern int sock_no_connect(struct socket *,
993 struct sockaddr *, int, int);
994extern int sock_no_socketpair(struct socket *,
995 struct socket *);
996extern int sock_no_accept(struct socket *,
997 struct socket *, int);
998extern int sock_no_getname(struct socket *,
999 struct sockaddr *, int *, int);
1000extern unsigned int sock_no_poll(struct file *, struct socket *,
1001 struct poll_table_struct *);
1002extern int sock_no_ioctl(struct socket *, unsigned int,
1003 unsigned long);
1004extern int sock_no_listen(struct socket *, int);
1005extern int sock_no_shutdown(struct socket *, int);
1006extern int sock_no_getsockopt(struct socket *, int , int,
1007 char __user *, int __user *);
1008extern int sock_no_setsockopt(struct socket *, int, int,
1009 char __user *, unsigned int);
1010extern int sock_no_sendmsg(struct kiocb *, struct socket *,
1011 struct msghdr *, size_t);
1012extern int sock_no_recvmsg(struct kiocb *, struct socket *,
1013 struct msghdr *, size_t, int);
1014extern int sock_no_mmap(struct file *file,
1015 struct socket *sock,
1016 struct vm_area_struct *vma);
1017extern ssize_t sock_no_sendpage(struct socket *sock,
1018 struct page *page,
1019 int offset, size_t size,
1020 int flags);
1021
1022
1023
1024
1025
1026extern int sock_common_getsockopt(struct socket *sock, int level, int optname,
1027 char __user *optval, int __user *optlen);
1028extern int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1029 struct msghdr *msg, size_t size, int flags);
1030extern int sock_common_setsockopt(struct socket *sock, int level, int optname,
1031 char __user *optval, unsigned int optlen);
1032extern int compat_sock_common_getsockopt(struct socket *sock, int level,
1033 int optname, char __user *optval, int __user *optlen);
1034extern int compat_sock_common_setsockopt(struct socket *sock, int level,
1035 int optname, char __user *optval, unsigned int optlen);
1036
1037extern void sk_common_release(struct sock *sk);
1038
1039
1040
1041
1042
1043
1044extern void sock_init_data(struct socket *sock, struct sock *sk);
1045
1046
1047
1048
1049
1050
1051
1052
1053static inline void sk_filter_release(struct sk_filter *fp)
1054{
1055 if (atomic_dec_and_test(&fp->refcnt))
1056 kfree(fp);
1057}
1058
1059static inline void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
1060{
1061 unsigned int size = sk_filter_len(fp);
1062
1063 atomic_sub(size, &sk->sk_omem_alloc);
1064 sk_filter_release(fp);
1065}
1066
1067static inline void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
1068{
1069 atomic_inc(&fp->refcnt);
1070 atomic_add(sk_filter_len(fp), &sk->sk_omem_alloc);
1071}
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099static inline void sock_put(struct sock *sk)
1100{
1101 if (atomic_dec_and_test(&sk->sk_refcnt))
1102 sk_free(sk);
1103}
1104
1105extern int sk_receive_skb(struct sock *sk, struct sk_buff *skb,
1106 const int nested);
1107
1108static inline void sk_tx_queue_set(struct sock *sk, int tx_queue)
1109{
1110 sk->sk_tx_queue_mapping = tx_queue;
1111}
1112
1113static inline void sk_tx_queue_clear(struct sock *sk)
1114{
1115 sk->sk_tx_queue_mapping = -1;
1116}
1117
1118static inline int sk_tx_queue_get(const struct sock *sk)
1119{
1120 return sk->sk_tx_queue_mapping;
1121}
1122
1123static inline bool sk_tx_queue_recorded(const struct sock *sk)
1124{
1125 return (sk && sk->sk_tx_queue_mapping >= 0);
1126}
1127
1128static inline void sk_set_socket(struct sock *sk, struct socket *sock)
1129{
1130 sk_tx_queue_clear(sk);
1131 sk->sk_socket = sock;
1132}
1133
1134
1135
1136
1137
1138
1139
1140
1141static inline void sock_orphan(struct sock *sk)
1142{
1143 write_lock_bh(&sk->sk_callback_lock);
1144 sock_set_flag(sk, SOCK_DEAD);
1145 sk_set_socket(sk, NULL);
1146 sk->sk_sleep = NULL;
1147 write_unlock_bh(&sk->sk_callback_lock);
1148}
1149
1150static inline void sock_graft(struct sock *sk, struct socket *parent)
1151{
1152 write_lock_bh(&sk->sk_callback_lock);
1153 sk->sk_sleep = &parent->wait;
1154 parent->sk = sk;
1155 sk_set_socket(sk, parent);
1156 security_sock_graft(sk, parent);
1157 write_unlock_bh(&sk->sk_callback_lock);
1158}
1159
1160extern int sock_i_uid(struct sock *sk);
1161extern unsigned long sock_i_ino(struct sock *sk);
1162
1163static inline struct dst_entry *
1164__sk_dst_get(struct sock *sk)
1165{
1166 return sk->sk_dst_cache;
1167}
1168
1169static inline struct dst_entry *
1170sk_dst_get(struct sock *sk)
1171{
1172 struct dst_entry *dst;
1173
1174 read_lock(&sk->sk_dst_lock);
1175 dst = sk->sk_dst_cache;
1176 if (dst)
1177 dst_hold(dst);
1178 read_unlock(&sk->sk_dst_lock);
1179 return dst;
1180}
1181
1182static inline void
1183__sk_dst_set(struct sock *sk, struct dst_entry *dst)
1184{
1185 struct dst_entry *old_dst;
1186
1187 sk_tx_queue_clear(sk);
1188 old_dst = sk->sk_dst_cache;
1189 sk->sk_dst_cache = dst;
1190 dst_release(old_dst);
1191}
1192
1193static inline void
1194sk_dst_set(struct sock *sk, struct dst_entry *dst)
1195{
1196 write_lock(&sk->sk_dst_lock);
1197 __sk_dst_set(sk, dst);
1198 write_unlock(&sk->sk_dst_lock);
1199}
1200
1201static inline void
1202__sk_dst_reset(struct sock *sk)
1203{
1204 struct dst_entry *old_dst;
1205
1206 sk_tx_queue_clear(sk);
1207 old_dst = sk->sk_dst_cache;
1208 sk->sk_dst_cache = NULL;
1209 dst_release(old_dst);
1210}
1211
1212static inline void
1213sk_dst_reset(struct sock *sk)
1214{
1215 write_lock(&sk->sk_dst_lock);
1216 __sk_dst_reset(sk);
1217 write_unlock(&sk->sk_dst_lock);
1218}
1219
1220extern struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie);
1221
1222extern struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie);
1223
1224static inline int sk_can_gso(const struct sock *sk)
1225{
1226 return net_gso_ok(sk->sk_route_caps, sk->sk_gso_type);
1227}
1228
1229extern void sk_setup_caps(struct sock *sk, struct dst_entry *dst);
1230
1231static inline int skb_copy_to_page(struct sock *sk, char __user *from,
1232 struct sk_buff *skb, struct page *page,
1233 int off, int copy)
1234{
1235 if (skb->ip_summed == CHECKSUM_NONE) {
1236 int err = 0;
1237 __wsum csum = csum_and_copy_from_user(from,
1238 page_address(page) + off,
1239 copy, 0, &err);
1240 if (err)
1241 return err;
1242 skb->csum = csum_block_add(skb->csum, csum, skb->len);
1243 } else if (copy_from_user(page_address(page) + off, from, copy))
1244 return -EFAULT;
1245
1246 skb->len += copy;
1247 skb->data_len += copy;
1248 skb->truesize += copy;
1249 sk->sk_wmem_queued += copy;
1250 sk_mem_charge(sk, copy);
1251 return 0;
1252}
1253
1254
1255
1256
1257
1258
1259
1260static inline int sk_wmem_alloc_get(const struct sock *sk)
1261{
1262 return atomic_read(&sk->sk_wmem_alloc) - 1;
1263}
1264
1265
1266
1267
1268
1269
1270
1271static inline int sk_rmem_alloc_get(const struct sock *sk)
1272{
1273 return atomic_read(&sk->sk_rmem_alloc);
1274}
1275
1276
1277
1278
1279
1280
1281
1282static inline int sk_has_allocations(const struct sock *sk)
1283{
1284 return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
1285}
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320static inline int sk_has_sleeper(struct sock *sk)
1321{
1322
1323
1324
1325
1326
1327
1328 smp_mb__after_lock();
1329 return sk->sk_sleep && waitqueue_active(sk->sk_sleep);
1330}
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340static inline void sock_poll_wait(struct file *filp,
1341 wait_queue_head_t *wait_address, poll_table *p)
1342{
1343 if (p && wait_address) {
1344 poll_wait(filp, wait_address, p);
1345
1346
1347
1348
1349
1350
1351 smp_mb();
1352 }
1353}
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
1365{
1366 skb_orphan(skb);
1367 skb->sk = sk;
1368 skb->destructor = sock_wfree;
1369
1370
1371
1372
1373
1374 atomic_add(skb->truesize, &sk->sk_wmem_alloc);
1375}
1376
1377static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
1378{
1379 skb_orphan(skb);
1380 skb->sk = sk;
1381 skb->destructor = sock_rfree;
1382 atomic_add(skb->truesize, &sk->sk_rmem_alloc);
1383 sk_mem_charge(sk, skb->truesize);
1384}
1385
1386extern void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1387 unsigned long expires);
1388
1389extern void sk_stop_timer(struct sock *sk, struct timer_list* timer);
1390
1391extern int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
1392
1393static inline int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
1394{
1395
1396
1397
1398 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
1399 (unsigned)sk->sk_rcvbuf)
1400 return -ENOMEM;
1401 skb_set_owner_r(skb, sk);
1402 skb_queue_tail(&sk->sk_error_queue, skb);
1403 if (!sock_flag(sk, SOCK_DEAD))
1404 sk->sk_data_ready(sk, skb->len);
1405 return 0;
1406}
1407
1408
1409
1410
1411
1412static inline int sock_error(struct sock *sk)
1413{
1414 int err;
1415 if (likely(!sk->sk_err))
1416 return 0;
1417 err = xchg(&sk->sk_err, 0);
1418 return -err;
1419}
1420
1421static inline unsigned long sock_wspace(struct sock *sk)
1422{
1423 int amt = 0;
1424
1425 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
1426 amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1427 if (amt < 0)
1428 amt = 0;
1429 }
1430 return amt;
1431}
1432
1433static inline void sk_wake_async(struct sock *sk, int how, int band)
1434{
1435 if (sock_flag(sk, SOCK_FASYNC))
1436 sock_wake_async(sk->sk_socket, how, band);
1437}
1438
1439#define SOCK_MIN_SNDBUF 2048
1440#define SOCK_MIN_RCVBUF 256
1441
1442static inline void sk_stream_moderate_sndbuf(struct sock *sk)
1443{
1444 if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
1445 sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
1446 sk->sk_sndbuf = max(sk->sk_sndbuf, SOCK_MIN_SNDBUF);
1447 }
1448}
1449
1450struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp);
1451
1452static inline struct page *sk_stream_alloc_page(struct sock *sk)
1453{
1454 struct page *page = NULL;
1455
1456 page = alloc_pages(sk->sk_allocation, 0);
1457 if (!page) {
1458 sk->sk_prot->enter_memory_pressure(sk);
1459 sk_stream_moderate_sndbuf(sk);
1460 }
1461 return page;
1462}
1463
1464
1465
1466
1467static inline int sock_writeable(const struct sock *sk)
1468{
1469 return atomic_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);
1470}
1471
1472static inline gfp_t gfp_any(void)
1473{
1474 return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
1475}
1476
1477static inline long sock_rcvtimeo(const struct sock *sk, int noblock)
1478{
1479 return noblock ? 0 : sk->sk_rcvtimeo;
1480}
1481
1482static inline long sock_sndtimeo(const struct sock *sk, int noblock)
1483{
1484 return noblock ? 0 : sk->sk_sndtimeo;
1485}
1486
1487static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
1488{
1489 return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;
1490}
1491
1492
1493
1494
1495static inline int sock_intr_errno(long timeo)
1496{
1497 return timeo == MAX_SCHEDULE_TIMEOUT ? -ERESTARTSYS : -EINTR;
1498}
1499
1500extern void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
1501 struct sk_buff *skb);
1502
1503static __inline__ void
1504sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
1505{
1506 ktime_t kt = skb->tstamp;
1507 struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519 if (sock_flag(sk, SOCK_RCVTSTAMP) ||
1520 sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE) ||
1521 (kt.tv64 && sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) ||
1522 (hwtstamps->hwtstamp.tv64 &&
1523 sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE)) ||
1524 (hwtstamps->syststamp.tv64 &&
1525 sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE)))
1526 __sock_recv_timestamp(msg, sk, skb);
1527 else
1528 sk->sk_stamp = kt;
1529}
1530
1531extern void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk, struct sk_buff *skb);
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542extern int sock_tx_timestamp(struct msghdr *msg,
1543 struct sock *sk,
1544 union skb_shared_tx *shtx);
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556#ifdef CONFIG_NET_DMA
1557static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
1558{
1559 __skb_unlink(skb, &sk->sk_receive_queue);
1560 if (!copied_early)
1561 __kfree_skb(skb);
1562 else
1563 __skb_queue_tail(&sk->sk_async_wait_queue, skb);
1564}
1565#else
1566static 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 __kfree_skb(skb);
1570}
1571#endif
1572
1573static inline
1574struct net *sock_net(const struct sock *sk)
1575{
1576#ifdef CONFIG_NET_NS
1577 return sk->sk_net;
1578#else
1579 return &init_net;
1580#endif
1581}
1582
1583static inline
1584void sock_net_set(struct sock *sk, struct net *net)
1585{
1586#ifdef CONFIG_NET_NS
1587 sk->sk_net = net;
1588#endif
1589}
1590
1591
1592
1593
1594
1595
1596
1597static inline void sk_change_net(struct sock *sk, struct net *net)
1598{
1599 put_net(sock_net(sk));
1600 sock_net_set(sk, hold_net(net));
1601}
1602
1603static inline struct sock *skb_steal_sock(struct sk_buff *skb)
1604{
1605 if (unlikely(skb->sk)) {
1606 struct sock *sk = skb->sk;
1607
1608 skb->destructor = NULL;
1609 skb->sk = NULL;
1610 return sk;
1611 }
1612 return NULL;
1613}
1614
1615extern void sock_enable_timestamp(struct sock *sk, int flag);
1616extern int sock_get_timestamp(struct sock *, struct timeval __user *);
1617extern int sock_get_timestampns(struct sock *, struct timespec __user *);
1618
1619
1620
1621
1622extern int net_msg_warn;
1623#define NETDEBUG(fmt, args...) \
1624 do { if (net_msg_warn) printk(fmt,##args); } while (0)
1625
1626#define LIMIT_NETDEBUG(fmt, args...) \
1627 do { if (net_msg_warn && net_ratelimit()) printk(fmt,##args); } while(0)
1628
1629extern __u32 sysctl_wmem_max;
1630extern __u32 sysctl_rmem_max;
1631
1632extern void sk_init(void);
1633
1634extern int sysctl_optmem_max;
1635
1636extern __u32 sysctl_wmem_default;
1637extern __u32 sysctl_rmem_default;
1638
1639#endif
1640