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/hardirq.h>
44#include <linux/kernel.h>
45#include <linux/list.h>
46#include <linux/list_nulls.h>
47#include <linux/timer.h>
48#include <linux/cache.h>
49#include <linux/bitops.h>
50#include <linux/lockdep.h>
51#include <linux/netdevice.h>
52#include <linux/skbuff.h>
53#include <linux/mm.h>
54#include <linux/security.h>
55#include <linux/slab.h>
56#include <linux/uaccess.h>
57#include <linux/page_counter.h>
58#include <linux/memcontrol.h>
59#include <linux/static_key.h>
60#include <linux/sched.h>
61#include <linux/wait.h>
62#include <linux/cgroup-defs.h>
63
64#include <linux/filter.h>
65#include <linux/rculist_nulls.h>
66#include <linux/poll.h>
67
68#include <linux/atomic.h>
69#include <net/dst.h>
70#include <net/checksum.h>
71#include <net/tcp_states.h>
72#include <linux/net_tstamp.h>
73
74
75
76
77
78
79
80
81#define SOCK_DEBUGGING
82#ifdef SOCK_DEBUGGING
83#define SOCK_DEBUG(sk, msg...) do { if ((sk) && sock_flag((sk), SOCK_DBG)) \
84 printk(KERN_DEBUG msg); } while (0)
85#else
86
87static inline __printf(2, 3)
88void SOCK_DEBUG(const struct sock *sk, const char *msg, ...)
89{
90}
91#endif
92
93
94
95
96
97typedef struct {
98 spinlock_t slock;
99 int owned;
100 wait_queue_head_t wq;
101
102
103
104
105
106
107#ifdef CONFIG_DEBUG_LOCK_ALLOC
108 struct lockdep_map dep_map;
109#endif
110} socket_lock_t;
111
112struct sock;
113struct proto;
114struct net;
115
116typedef __u32 __bitwise __portpair;
117typedef __u64 __bitwise __addrpair;
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148struct sock_common {
149
150
151
152 union {
153 __addrpair skc_addrpair;
154 struct {
155 __be32 skc_daddr;
156 __be32 skc_rcv_saddr;
157 };
158 };
159 union {
160 unsigned int skc_hash;
161 __u16 skc_u16hashes[2];
162 };
163
164 union {
165 __portpair skc_portpair;
166 struct {
167 __be16 skc_dport;
168 __u16 skc_num;
169 };
170 };
171
172 unsigned short skc_family;
173 volatile unsigned char skc_state;
174 unsigned char skc_reuse:4;
175 unsigned char skc_reuseport:1;
176 unsigned char skc_ipv6only:1;
177 unsigned char skc_net_refcnt:1;
178 int skc_bound_dev_if;
179 union {
180 struct hlist_node skc_bind_node;
181 struct hlist_node skc_portaddr_node;
182 };
183 struct proto *skc_prot;
184 possible_net_t skc_net;
185
186#if IS_ENABLED(CONFIG_IPV6)
187 struct in6_addr skc_v6_daddr;
188 struct in6_addr skc_v6_rcv_saddr;
189#endif
190
191 atomic64_t skc_cookie;
192
193
194
195
196
197
198 union {
199 unsigned long skc_flags;
200 struct sock *skc_listener;
201 struct inet_timewait_death_row *skc_tw_dr;
202 };
203
204
205
206
207
208 int skc_dontcopy_begin[0];
209
210 union {
211 struct hlist_node skc_node;
212 struct hlist_nulls_node skc_nulls_node;
213 };
214 int skc_tx_queue_mapping;
215 union {
216 int skc_incoming_cpu;
217 u32 skc_rcv_wnd;
218 u32 skc_tw_rcv_nxt;
219 };
220
221 atomic_t skc_refcnt;
222
223 int skc_dontcopy_end[0];
224 union {
225 u32 skc_rxhash;
226 u32 skc_window_clamp;
227 u32 skc_tw_snd_nxt;
228 };
229
230};
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308struct sock {
309
310
311
312
313 struct sock_common __sk_common;
314#define sk_node __sk_common.skc_node
315#define sk_nulls_node __sk_common.skc_nulls_node
316#define sk_refcnt __sk_common.skc_refcnt
317#define sk_tx_queue_mapping __sk_common.skc_tx_queue_mapping
318
319#define sk_dontcopy_begin __sk_common.skc_dontcopy_begin
320#define sk_dontcopy_end __sk_common.skc_dontcopy_end
321#define sk_hash __sk_common.skc_hash
322#define sk_portpair __sk_common.skc_portpair
323#define sk_num __sk_common.skc_num
324#define sk_dport __sk_common.skc_dport
325#define sk_addrpair __sk_common.skc_addrpair
326#define sk_daddr __sk_common.skc_daddr
327#define sk_rcv_saddr __sk_common.skc_rcv_saddr
328#define sk_family __sk_common.skc_family
329#define sk_state __sk_common.skc_state
330#define sk_reuse __sk_common.skc_reuse
331#define sk_reuseport __sk_common.skc_reuseport
332#define sk_ipv6only __sk_common.skc_ipv6only
333#define sk_net_refcnt __sk_common.skc_net_refcnt
334#define sk_bound_dev_if __sk_common.skc_bound_dev_if
335#define sk_bind_node __sk_common.skc_bind_node
336#define sk_prot __sk_common.skc_prot
337#define sk_net __sk_common.skc_net
338#define sk_v6_daddr __sk_common.skc_v6_daddr
339#define sk_v6_rcv_saddr __sk_common.skc_v6_rcv_saddr
340#define sk_cookie __sk_common.skc_cookie
341#define sk_incoming_cpu __sk_common.skc_incoming_cpu
342#define sk_flags __sk_common.skc_flags
343#define sk_rxhash __sk_common.skc_rxhash
344
345 socket_lock_t sk_lock;
346 struct sk_buff_head sk_receive_queue;
347
348
349
350
351
352
353
354
355 struct {
356 atomic_t rmem_alloc;
357 int len;
358 struct sk_buff *head;
359 struct sk_buff *tail;
360 } sk_backlog;
361#define sk_rmem_alloc sk_backlog.rmem_alloc
362 int sk_forward_alloc;
363
364 __u32 sk_txhash;
365#ifdef CONFIG_NET_RX_BUSY_POLL
366 unsigned int sk_napi_id;
367 unsigned int sk_ll_usec;
368#endif
369 atomic_t sk_drops;
370 int sk_rcvbuf;
371
372 struct sk_filter __rcu *sk_filter;
373 union {
374 struct socket_wq __rcu *sk_wq;
375 struct socket_wq *sk_wq_raw;
376 };
377#ifdef CONFIG_XFRM
378 struct xfrm_policy __rcu *sk_policy[2];
379#endif
380 struct dst_entry *sk_rx_dst;
381 struct dst_entry __rcu *sk_dst_cache;
382
383 atomic_t sk_wmem_alloc;
384 atomic_t sk_omem_alloc;
385 int sk_sndbuf;
386 struct sk_buff_head sk_write_queue;
387
388
389
390
391
392 kmemcheck_bitfield_begin(flags);
393 unsigned int sk_padding : 2,
394 sk_no_check_tx : 1,
395 sk_no_check_rx : 1,
396 sk_userlocks : 4,
397 sk_protocol : 8,
398 sk_type : 16;
399#define SK_PROTOCOL_MAX U8_MAX
400 kmemcheck_bitfield_end(flags);
401
402 int sk_wmem_queued;
403 gfp_t sk_allocation;
404 u32 sk_pacing_rate;
405 u32 sk_max_pacing_rate;
406 netdev_features_t sk_route_caps;
407 netdev_features_t sk_route_nocaps;
408 int sk_gso_type;
409 unsigned int sk_gso_max_size;
410 u16 sk_gso_max_segs;
411 int sk_rcvlowat;
412 unsigned long sk_lingertime;
413 struct sk_buff_head sk_error_queue;
414 struct proto *sk_prot_creator;
415 rwlock_t sk_callback_lock;
416 int sk_err,
417 sk_err_soft;
418 u32 sk_ack_backlog;
419 u32 sk_max_ack_backlog;
420 __u32 sk_priority;
421 __u32 sk_mark;
422 struct pid *sk_peer_pid;
423 const struct cred *sk_peer_cred;
424 long sk_rcvtimeo;
425 long sk_sndtimeo;
426 struct timer_list sk_timer;
427 ktime_t sk_stamp;
428 u16 sk_tsflags;
429 u8 sk_shutdown;
430 u32 sk_tskey;
431 struct socket *sk_socket;
432 void *sk_user_data;
433 struct page_frag sk_frag;
434 struct sk_buff *sk_send_head;
435 __s32 sk_peek_off;
436 int sk_write_pending;
437#ifdef CONFIG_SECURITY
438 void *sk_security;
439#endif
440 struct sock_cgroup_data sk_cgrp_data;
441 struct mem_cgroup *sk_memcg;
442 void (*sk_state_change)(struct sock *sk);
443 void (*sk_data_ready)(struct sock *sk);
444 void (*sk_write_space)(struct sock *sk);
445 void (*sk_error_report)(struct sock *sk);
446 int (*sk_backlog_rcv)(struct sock *sk,
447 struct sk_buff *skb);
448 void (*sk_destruct)(struct sock *sk);
449 struct sock_reuseport __rcu *sk_reuseport_cb;
450 struct rcu_head sk_rcu;
451};
452
453#define __sk_user_data(sk) ((*((void __rcu **)&(sk)->sk_user_data)))
454
455#define rcu_dereference_sk_user_data(sk) rcu_dereference(__sk_user_data((sk)))
456#define rcu_assign_sk_user_data(sk, ptr) rcu_assign_pointer(__sk_user_data((sk)), ptr)
457
458
459
460
461
462
463
464
465#define SK_NO_REUSE 0
466#define SK_CAN_REUSE 1
467#define SK_FORCE_REUSE 2
468
469int sk_set_peek_off(struct sock *sk, int val);
470
471static inline int sk_peek_offset(struct sock *sk, int flags)
472{
473 if (unlikely(flags & MSG_PEEK)) {
474 s32 off = READ_ONCE(sk->sk_peek_off);
475 if (off >= 0)
476 return off;
477 }
478
479 return 0;
480}
481
482static inline void sk_peek_offset_bwd(struct sock *sk, int val)
483{
484 s32 off = READ_ONCE(sk->sk_peek_off);
485
486 if (unlikely(off >= 0)) {
487 off = max_t(s32, off - val, 0);
488 WRITE_ONCE(sk->sk_peek_off, off);
489 }
490}
491
492static inline void sk_peek_offset_fwd(struct sock *sk, int val)
493{
494 sk_peek_offset_bwd(sk, -val);
495}
496
497
498
499
500static inline struct sock *sk_entry(const struct hlist_node *node)
501{
502 return hlist_entry(node, struct sock, sk_node);
503}
504
505static inline struct sock *__sk_head(const struct hlist_head *head)
506{
507 return hlist_entry(head->first, struct sock, sk_node);
508}
509
510static inline struct sock *sk_head(const struct hlist_head *head)
511{
512 return hlist_empty(head) ? NULL : __sk_head(head);
513}
514
515static inline struct sock *__sk_nulls_head(const struct hlist_nulls_head *head)
516{
517 return hlist_nulls_entry(head->first, struct sock, sk_nulls_node);
518}
519
520static inline struct sock *sk_nulls_head(const struct hlist_nulls_head *head)
521{
522 return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
523}
524
525static inline struct sock *sk_next(const struct sock *sk)
526{
527 return sk->sk_node.next ?
528 hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
529}
530
531static inline struct sock *sk_nulls_next(const struct sock *sk)
532{
533 return (!is_a_nulls(sk->sk_nulls_node.next)) ?
534 hlist_nulls_entry(sk->sk_nulls_node.next,
535 struct sock, sk_nulls_node) :
536 NULL;
537}
538
539static inline bool sk_unhashed(const struct sock *sk)
540{
541 return hlist_unhashed(&sk->sk_node);
542}
543
544static inline bool sk_hashed(const struct sock *sk)
545{
546 return !sk_unhashed(sk);
547}
548
549static inline void sk_node_init(struct hlist_node *node)
550{
551 node->pprev = NULL;
552}
553
554static inline void sk_nulls_node_init(struct hlist_nulls_node *node)
555{
556 node->pprev = NULL;
557}
558
559static inline void __sk_del_node(struct sock *sk)
560{
561 __hlist_del(&sk->sk_node);
562}
563
564
565static inline bool __sk_del_node_init(struct sock *sk)
566{
567 if (sk_hashed(sk)) {
568 __sk_del_node(sk);
569 sk_node_init(&sk->sk_node);
570 return true;
571 }
572 return false;
573}
574
575
576
577
578
579
580
581static __always_inline void sock_hold(struct sock *sk)
582{
583 atomic_inc(&sk->sk_refcnt);
584}
585
586
587
588
589static __always_inline void __sock_put(struct sock *sk)
590{
591 atomic_dec(&sk->sk_refcnt);
592}
593
594static inline bool sk_del_node_init(struct sock *sk)
595{
596 bool rc = __sk_del_node_init(sk);
597
598 if (rc) {
599
600 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
601 __sock_put(sk);
602 }
603 return rc;
604}
605#define sk_del_node_init_rcu(sk) sk_del_node_init(sk)
606
607static inline bool __sk_nulls_del_node_init_rcu(struct sock *sk)
608{
609 if (sk_hashed(sk)) {
610 hlist_nulls_del_init_rcu(&sk->sk_nulls_node);
611 return true;
612 }
613 return false;
614}
615
616static inline bool sk_nulls_del_node_init_rcu(struct sock *sk)
617{
618 bool rc = __sk_nulls_del_node_init_rcu(sk);
619
620 if (rc) {
621
622 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
623 __sock_put(sk);
624 }
625 return rc;
626}
627
628static inline void __sk_add_node(struct sock *sk, struct hlist_head *list)
629{
630 hlist_add_head(&sk->sk_node, list);
631}
632
633static inline void sk_add_node(struct sock *sk, struct hlist_head *list)
634{
635 sock_hold(sk);
636 __sk_add_node(sk, list);
637}
638
639static inline void sk_add_node_rcu(struct sock *sk, struct hlist_head *list)
640{
641 sock_hold(sk);
642 if (IS_ENABLED(CONFIG_IPV6) && sk->sk_reuseport &&
643 sk->sk_family == AF_INET6)
644 hlist_add_tail_rcu(&sk->sk_node, list);
645 else
646 hlist_add_head_rcu(&sk->sk_node, list);
647}
648
649static inline void __sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
650{
651 if (IS_ENABLED(CONFIG_IPV6) && sk->sk_reuseport &&
652 sk->sk_family == AF_INET6)
653 hlist_nulls_add_tail_rcu(&sk->sk_nulls_node, list);
654 else
655 hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
656}
657
658static inline void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
659{
660 sock_hold(sk);
661 __sk_nulls_add_node_rcu(sk, list);
662}
663
664static inline void __sk_del_bind_node(struct sock *sk)
665{
666 __hlist_del(&sk->sk_bind_node);
667}
668
669static inline void sk_add_bind_node(struct sock *sk,
670 struct hlist_head *list)
671{
672 hlist_add_head(&sk->sk_bind_node, list);
673}
674
675#define sk_for_each(__sk, list) \
676 hlist_for_each_entry(__sk, list, sk_node)
677#define sk_for_each_rcu(__sk, list) \
678 hlist_for_each_entry_rcu(__sk, list, sk_node)
679#define sk_nulls_for_each(__sk, node, list) \
680 hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)
681#define sk_nulls_for_each_rcu(__sk, node, list) \
682 hlist_nulls_for_each_entry_rcu(__sk, node, list, sk_nulls_node)
683#define sk_for_each_from(__sk) \
684 hlist_for_each_entry_from(__sk, sk_node)
685#define sk_nulls_for_each_from(__sk, node) \
686 if (__sk && ({ node = &(__sk)->sk_nulls_node; 1; })) \
687 hlist_nulls_for_each_entry_from(__sk, node, sk_nulls_node)
688#define sk_for_each_safe(__sk, tmp, list) \
689 hlist_for_each_entry_safe(__sk, tmp, list, sk_node)
690#define sk_for_each_bound(__sk, list) \
691 hlist_for_each_entry(__sk, list, sk_bind_node)
692
693
694
695
696
697
698
699
700
701#define sk_for_each_entry_offset_rcu(tpos, pos, head, offset) \
702 for (pos = rcu_dereference((head)->first); \
703 pos != NULL && \
704 ({ tpos = (typeof(*tpos) *)((void *)pos - offset); 1;}); \
705 pos = rcu_dereference(pos->next))
706
707static inline struct user_namespace *sk_user_ns(struct sock *sk)
708{
709
710
711
712
713 return sk->sk_socket->file->f_cred->user_ns;
714}
715
716
717enum sock_flags {
718 SOCK_DEAD,
719 SOCK_DONE,
720 SOCK_URGINLINE,
721 SOCK_KEEPOPEN,
722 SOCK_LINGER,
723 SOCK_DESTROY,
724 SOCK_BROADCAST,
725 SOCK_TIMESTAMP,
726 SOCK_ZAPPED,
727 SOCK_USE_WRITE_QUEUE,
728 SOCK_DBG,
729 SOCK_RCVTSTAMP,
730 SOCK_RCVTSTAMPNS,
731 SOCK_LOCALROUTE,
732 SOCK_QUEUE_SHRUNK,
733 SOCK_MEMALLOC,
734 SOCK_TIMESTAMPING_RX_SOFTWARE,
735 SOCK_FASYNC,
736 SOCK_RXQ_OVFL,
737 SOCK_ZEROCOPY,
738 SOCK_WIFI_STATUS,
739 SOCK_NOFCS,
740
741
742
743 SOCK_FILTER_LOCKED,
744 SOCK_SELECT_ERR_QUEUE,
745 SOCK_RCU_FREE,
746};
747
748#define SK_FLAGS_TIMESTAMP ((1UL << SOCK_TIMESTAMP) | (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE))
749
750static inline void sock_copy_flags(struct sock *nsk, struct sock *osk)
751{
752 nsk->sk_flags = osk->sk_flags;
753}
754
755static inline void sock_set_flag(struct sock *sk, enum sock_flags flag)
756{
757 __set_bit(flag, &sk->sk_flags);
758}
759
760static inline void sock_reset_flag(struct sock *sk, enum sock_flags flag)
761{
762 __clear_bit(flag, &sk->sk_flags);
763}
764
765static inline bool sock_flag(const struct sock *sk, enum sock_flags flag)
766{
767 return test_bit(flag, &sk->sk_flags);
768}
769
770#ifdef CONFIG_NET
771extern struct static_key memalloc_socks;
772static inline int sk_memalloc_socks(void)
773{
774 return static_key_false(&memalloc_socks);
775}
776#else
777
778static inline int sk_memalloc_socks(void)
779{
780 return 0;
781}
782
783#endif
784
785static inline gfp_t sk_gfp_mask(const struct sock *sk, gfp_t gfp_mask)
786{
787 return gfp_mask | (sk->sk_allocation & __GFP_MEMALLOC);
788}
789
790static inline void sk_acceptq_removed(struct sock *sk)
791{
792 sk->sk_ack_backlog--;
793}
794
795static inline void sk_acceptq_added(struct sock *sk)
796{
797 sk->sk_ack_backlog++;
798}
799
800static inline bool sk_acceptq_is_full(const struct sock *sk)
801{
802 return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
803}
804
805
806
807
808static inline int sk_stream_min_wspace(const struct sock *sk)
809{
810 return sk->sk_wmem_queued >> 1;
811}
812
813static inline int sk_stream_wspace(const struct sock *sk)
814{
815 return sk->sk_sndbuf - sk->sk_wmem_queued;
816}
817
818void sk_stream_write_space(struct sock *sk);
819
820
821static inline void __sk_add_backlog(struct sock *sk, struct sk_buff *skb)
822{
823
824 skb_dst_force_safe(skb);
825
826 if (!sk->sk_backlog.tail)
827 sk->sk_backlog.head = skb;
828 else
829 sk->sk_backlog.tail->next = skb;
830
831 sk->sk_backlog.tail = skb;
832 skb->next = NULL;
833}
834
835
836
837
838
839
840static inline bool sk_rcvqueues_full(const struct sock *sk, unsigned int limit)
841{
842 unsigned int qsize = sk->sk_backlog.len + atomic_read(&sk->sk_rmem_alloc);
843
844 return qsize > limit;
845}
846
847
848static inline __must_check int sk_add_backlog(struct sock *sk, struct sk_buff *skb,
849 unsigned int limit)
850{
851 if (sk_rcvqueues_full(sk, limit))
852 return -ENOBUFS;
853
854
855
856
857
858
859 if (skb_pfmemalloc(skb) && !sock_flag(sk, SOCK_MEMALLOC))
860 return -ENOMEM;
861
862 __sk_add_backlog(sk, skb);
863 sk->sk_backlog.len += skb->truesize;
864 return 0;
865}
866
867int __sk_backlog_rcv(struct sock *sk, struct sk_buff *skb);
868
869static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
870{
871 if (sk_memalloc_socks() && skb_pfmemalloc(skb))
872 return __sk_backlog_rcv(sk, skb);
873
874 return sk->sk_backlog_rcv(sk, skb);
875}
876
877static inline void sk_incoming_cpu_update(struct sock *sk)
878{
879 sk->sk_incoming_cpu = raw_smp_processor_id();
880}
881
882static inline void sock_rps_record_flow_hash(__u32 hash)
883{
884#ifdef CONFIG_RPS
885 struct rps_sock_flow_table *sock_flow_table;
886
887 rcu_read_lock();
888 sock_flow_table = rcu_dereference(rps_sock_flow_table);
889 rps_record_sock_flow(sock_flow_table, hash);
890 rcu_read_unlock();
891#endif
892}
893
894static inline void sock_rps_record_flow(const struct sock *sk)
895{
896#ifdef CONFIG_RPS
897 sock_rps_record_flow_hash(sk->sk_rxhash);
898#endif
899}
900
901static inline void sock_rps_save_rxhash(struct sock *sk,
902 const struct sk_buff *skb)
903{
904#ifdef CONFIG_RPS
905 if (unlikely(sk->sk_rxhash != skb->hash))
906 sk->sk_rxhash = skb->hash;
907#endif
908}
909
910static inline void sock_rps_reset_rxhash(struct sock *sk)
911{
912#ifdef CONFIG_RPS
913 sk->sk_rxhash = 0;
914#endif
915}
916
917#define sk_wait_event(__sk, __timeo, __condition) \
918 ({ int __rc; \
919 release_sock(__sk); \
920 __rc = __condition; \
921 if (!__rc) { \
922 *(__timeo) = schedule_timeout(*(__timeo)); \
923 } \
924 sched_annotate_sleep(); \
925 lock_sock(__sk); \
926 __rc = __condition; \
927 __rc; \
928 })
929
930int sk_stream_wait_connect(struct sock *sk, long *timeo_p);
931int sk_stream_wait_memory(struct sock *sk, long *timeo_p);
932void sk_stream_wait_close(struct sock *sk, long timeo_p);
933int sk_stream_error(struct sock *sk, int flags, int err);
934void sk_stream_kill_queues(struct sock *sk);
935void sk_set_memalloc(struct sock *sk);
936void sk_clear_memalloc(struct sock *sk);
937
938void __sk_flush_backlog(struct sock *sk);
939
940static inline bool sk_flush_backlog(struct sock *sk)
941{
942 if (unlikely(READ_ONCE(sk->sk_backlog.tail))) {
943 __sk_flush_backlog(sk);
944 return true;
945 }
946 return false;
947}
948
949int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb);
950
951struct request_sock_ops;
952struct timewait_sock_ops;
953struct inet_hashinfo;
954struct raw_hashinfo;
955struct module;
956
957
958
959
960
961static inline void sk_prot_clear_nulls(struct sock *sk, int size)
962{
963 if (offsetof(struct sock, sk_node.next) != 0)
964 memset(sk, 0, offsetof(struct sock, sk_node.next));
965 memset(&sk->sk_node.pprev, 0,
966 size - offsetof(struct sock, sk_node.pprev));
967}
968
969
970
971
972struct proto {
973 void (*close)(struct sock *sk,
974 long timeout);
975 int (*connect)(struct sock *sk,
976 struct sockaddr *uaddr,
977 int addr_len);
978 int (*disconnect)(struct sock *sk, int flags);
979
980 struct sock * (*accept)(struct sock *sk, int flags, int *err);
981
982 int (*ioctl)(struct sock *sk, int cmd,
983 unsigned long arg);
984 int (*init)(struct sock *sk);
985 void (*destroy)(struct sock *sk);
986 void (*shutdown)(struct sock *sk, int how);
987 int (*setsockopt)(struct sock *sk, int level,
988 int optname, char __user *optval,
989 unsigned int optlen);
990 int (*getsockopt)(struct sock *sk, int level,
991 int optname, char __user *optval,
992 int __user *option);
993#ifdef CONFIG_COMPAT
994 int (*compat_setsockopt)(struct sock *sk,
995 int level,
996 int optname, char __user *optval,
997 unsigned int optlen);
998 int (*compat_getsockopt)(struct sock *sk,
999 int level,
1000 int optname, char __user *optval,
1001 int __user *option);
1002 int (*compat_ioctl)(struct sock *sk,
1003 unsigned int cmd, unsigned long arg);
1004#endif
1005 int (*sendmsg)(struct sock *sk, struct msghdr *msg,
1006 size_t len);
1007 int (*recvmsg)(struct sock *sk, struct msghdr *msg,
1008 size_t len, int noblock, int flags,
1009 int *addr_len);
1010 int (*sendpage)(struct sock *sk, struct page *page,
1011 int offset, size_t size, int flags);
1012 int (*bind)(struct sock *sk,
1013 struct sockaddr *uaddr, int addr_len);
1014
1015 int (*backlog_rcv) (struct sock *sk,
1016 struct sk_buff *skb);
1017
1018 void (*release_cb)(struct sock *sk);
1019
1020
1021 int (*hash)(struct sock *sk);
1022 void (*unhash)(struct sock *sk);
1023 void (*rehash)(struct sock *sk);
1024 int (*get_port)(struct sock *sk, unsigned short snum);
1025
1026
1027#ifdef CONFIG_PROC_FS
1028 unsigned int inuse_idx;
1029#endif
1030
1031 bool (*stream_memory_free)(const struct sock *sk);
1032
1033 void (*enter_memory_pressure)(struct sock *sk);
1034 atomic_long_t *memory_allocated;
1035 struct percpu_counter *sockets_allocated;
1036
1037
1038
1039
1040
1041
1042 int *memory_pressure;
1043 long *sysctl_mem;
1044 int *sysctl_wmem;
1045 int *sysctl_rmem;
1046 int max_header;
1047 bool no_autobind;
1048
1049 struct kmem_cache *slab;
1050 unsigned int obj_size;
1051 int slab_flags;
1052
1053 struct percpu_counter *orphan_count;
1054
1055 struct request_sock_ops *rsk_prot;
1056 struct timewait_sock_ops *twsk_prot;
1057
1058 union {
1059 struct inet_hashinfo *hashinfo;
1060 struct udp_table *udp_table;
1061 struct raw_hashinfo *raw_hash;
1062 } h;
1063
1064 struct module *owner;
1065
1066 char name[32];
1067
1068 struct list_head node;
1069#ifdef SOCK_REFCNT_DEBUG
1070 atomic_t socks;
1071#endif
1072 int (*diag_destroy)(struct sock *sk, int err);
1073};
1074
1075int proto_register(struct proto *prot, int alloc_slab);
1076void proto_unregister(struct proto *prot);
1077
1078#ifdef SOCK_REFCNT_DEBUG
1079static inline void sk_refcnt_debug_inc(struct sock *sk)
1080{
1081 atomic_inc(&sk->sk_prot->socks);
1082}
1083
1084static inline void sk_refcnt_debug_dec(struct sock *sk)
1085{
1086 atomic_dec(&sk->sk_prot->socks);
1087 printk(KERN_DEBUG "%s socket %p released, %d are still alive\n",
1088 sk->sk_prot->name, sk, atomic_read(&sk->sk_prot->socks));
1089}
1090
1091static inline void sk_refcnt_debug_release(const struct sock *sk)
1092{
1093 if (atomic_read(&sk->sk_refcnt) != 1)
1094 printk(KERN_DEBUG "Destruction of the %s socket %p delayed, refcnt=%d\n",
1095 sk->sk_prot->name, sk, atomic_read(&sk->sk_refcnt));
1096}
1097#else
1098#define sk_refcnt_debug_inc(sk) do { } while (0)
1099#define sk_refcnt_debug_dec(sk) do { } while (0)
1100#define sk_refcnt_debug_release(sk) do { } while (0)
1101#endif
1102
1103static inline bool sk_stream_memory_free(const struct sock *sk)
1104{
1105 if (sk->sk_wmem_queued >= sk->sk_sndbuf)
1106 return false;
1107
1108 return sk->sk_prot->stream_memory_free ?
1109 sk->sk_prot->stream_memory_free(sk) : true;
1110}
1111
1112static inline bool sk_stream_is_writeable(const struct sock *sk)
1113{
1114 return sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) &&
1115 sk_stream_memory_free(sk);
1116}
1117
1118static inline int sk_under_cgroup_hierarchy(struct sock *sk,
1119 struct cgroup *ancestor)
1120{
1121#ifdef CONFIG_SOCK_CGROUP_DATA
1122 return cgroup_is_descendant(sock_cgroup_ptr(&sk->sk_cgrp_data),
1123 ancestor);
1124#else
1125 return -ENOTSUPP;
1126#endif
1127}
1128
1129static inline bool sk_has_memory_pressure(const struct sock *sk)
1130{
1131 return sk->sk_prot->memory_pressure != NULL;
1132}
1133
1134static inline bool sk_under_memory_pressure(const struct sock *sk)
1135{
1136 if (!sk->sk_prot->memory_pressure)
1137 return false;
1138
1139 if (mem_cgroup_sockets_enabled && sk->sk_memcg &&
1140 mem_cgroup_under_socket_pressure(sk->sk_memcg))
1141 return true;
1142
1143 return !!*sk->sk_prot->memory_pressure;
1144}
1145
1146static inline void sk_leave_memory_pressure(struct sock *sk)
1147{
1148 int *memory_pressure = sk->sk_prot->memory_pressure;
1149
1150 if (!memory_pressure)
1151 return;
1152
1153 if (*memory_pressure)
1154 *memory_pressure = 0;
1155}
1156
1157static inline void sk_enter_memory_pressure(struct sock *sk)
1158{
1159 if (!sk->sk_prot->enter_memory_pressure)
1160 return;
1161
1162 sk->sk_prot->enter_memory_pressure(sk);
1163}
1164
1165static inline long sk_prot_mem_limits(const struct sock *sk, int index)
1166{
1167 return sk->sk_prot->sysctl_mem[index];
1168}
1169
1170static inline long
1171sk_memory_allocated(const struct sock *sk)
1172{
1173 return atomic_long_read(sk->sk_prot->memory_allocated);
1174}
1175
1176static inline long
1177sk_memory_allocated_add(struct sock *sk, int amt)
1178{
1179 return atomic_long_add_return(amt, sk->sk_prot->memory_allocated);
1180}
1181
1182static inline void
1183sk_memory_allocated_sub(struct sock *sk, int amt)
1184{
1185 atomic_long_sub(amt, sk->sk_prot->memory_allocated);
1186}
1187
1188static inline void sk_sockets_allocated_dec(struct sock *sk)
1189{
1190 percpu_counter_dec(sk->sk_prot->sockets_allocated);
1191}
1192
1193static inline void sk_sockets_allocated_inc(struct sock *sk)
1194{
1195 percpu_counter_inc(sk->sk_prot->sockets_allocated);
1196}
1197
1198static inline int
1199sk_sockets_allocated_read_positive(struct sock *sk)
1200{
1201 return percpu_counter_read_positive(sk->sk_prot->sockets_allocated);
1202}
1203
1204static inline int
1205proto_sockets_allocated_sum_positive(struct proto *prot)
1206{
1207 return percpu_counter_sum_positive(prot->sockets_allocated);
1208}
1209
1210static inline long
1211proto_memory_allocated(struct proto *prot)
1212{
1213 return atomic_long_read(prot->memory_allocated);
1214}
1215
1216static inline bool
1217proto_memory_pressure(struct proto *prot)
1218{
1219 if (!prot->memory_pressure)
1220 return false;
1221 return !!*prot->memory_pressure;
1222}
1223
1224
1225#ifdef CONFIG_PROC_FS
1226
1227void sock_prot_inuse_add(struct net *net, struct proto *prot, int inc);
1228int sock_prot_inuse_get(struct net *net, struct proto *proto);
1229#else
1230static inline void sock_prot_inuse_add(struct net *net, struct proto *prot,
1231 int inc)
1232{
1233}
1234#endif
1235
1236
1237
1238
1239
1240static inline int __sk_prot_rehash(struct sock *sk)
1241{
1242 sk->sk_prot->unhash(sk);
1243 return sk->sk_prot->hash(sk);
1244}
1245
1246
1247#define SOCK_DESTROY_TIME (10*HZ)
1248
1249
1250#define PROT_SOCK 1024
1251
1252#define SHUTDOWN_MASK 3
1253#define RCV_SHUTDOWN 1
1254#define SEND_SHUTDOWN 2
1255
1256#define SOCK_SNDBUF_LOCK 1
1257#define SOCK_RCVBUF_LOCK 2
1258#define SOCK_BINDADDR_LOCK 4
1259#define SOCK_BINDPORT_LOCK 8
1260
1261struct socket_alloc {
1262 struct socket socket;
1263 struct inode vfs_inode;
1264};
1265
1266static inline struct socket *SOCKET_I(struct inode *inode)
1267{
1268 return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
1269}
1270
1271static inline struct inode *SOCK_INODE(struct socket *socket)
1272{
1273 return &container_of(socket, struct socket_alloc, socket)->vfs_inode;
1274}
1275
1276
1277
1278
1279int __sk_mem_schedule(struct sock *sk, int size, int kind);
1280void __sk_mem_reclaim(struct sock *sk, int amount);
1281
1282#define SK_MEM_QUANTUM ((int)PAGE_SIZE)
1283#define SK_MEM_QUANTUM_SHIFT ilog2(SK_MEM_QUANTUM)
1284#define SK_MEM_SEND 0
1285#define SK_MEM_RECV 1
1286
1287static inline int sk_mem_pages(int amt)
1288{
1289 return (amt + SK_MEM_QUANTUM - 1) >> SK_MEM_QUANTUM_SHIFT;
1290}
1291
1292static inline bool sk_has_account(struct sock *sk)
1293{
1294
1295 return !!sk->sk_prot->memory_allocated;
1296}
1297
1298static inline bool sk_wmem_schedule(struct sock *sk, int size)
1299{
1300 if (!sk_has_account(sk))
1301 return true;
1302 return size <= sk->sk_forward_alloc ||
1303 __sk_mem_schedule(sk, size, SK_MEM_SEND);
1304}
1305
1306static inline bool
1307sk_rmem_schedule(struct sock *sk, struct sk_buff *skb, int size)
1308{
1309 if (!sk_has_account(sk))
1310 return true;
1311 return size<= sk->sk_forward_alloc ||
1312 __sk_mem_schedule(sk, size, SK_MEM_RECV) ||
1313 skb_pfmemalloc(skb);
1314}
1315
1316static inline void sk_mem_reclaim(struct sock *sk)
1317{
1318 if (!sk_has_account(sk))
1319 return;
1320 if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
1321 __sk_mem_reclaim(sk, sk->sk_forward_alloc);
1322}
1323
1324static inline void sk_mem_reclaim_partial(struct sock *sk)
1325{
1326 if (!sk_has_account(sk))
1327 return;
1328 if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
1329 __sk_mem_reclaim(sk, sk->sk_forward_alloc - 1);
1330}
1331
1332static inline void sk_mem_charge(struct sock *sk, int size)
1333{
1334 if (!sk_has_account(sk))
1335 return;
1336 sk->sk_forward_alloc -= size;
1337}
1338
1339static inline void sk_mem_uncharge(struct sock *sk, int size)
1340{
1341 if (!sk_has_account(sk))
1342 return;
1343 sk->sk_forward_alloc += size;
1344
1345
1346
1347
1348
1349
1350
1351
1352 if (unlikely(sk->sk_forward_alloc >= 1 << 21))
1353 __sk_mem_reclaim(sk, 1 << 20);
1354}
1355
1356static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
1357{
1358 sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
1359 sk->sk_wmem_queued -= skb->truesize;
1360 sk_mem_uncharge(sk, skb->truesize);
1361 __kfree_skb(skb);
1362}
1363
1364static inline void sock_release_ownership(struct sock *sk)
1365{
1366 if (sk->sk_lock.owned) {
1367 sk->sk_lock.owned = 0;
1368
1369
1370 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
1371 }
1372}
1373
1374
1375
1376
1377
1378
1379
1380
1381#define sock_lock_init_class_and_name(sk, sname, skey, name, key) \
1382do { \
1383 sk->sk_lock.owned = 0; \
1384 init_waitqueue_head(&sk->sk_lock.wq); \
1385 spin_lock_init(&(sk)->sk_lock.slock); \
1386 debug_check_no_locks_freed((void *)&(sk)->sk_lock, \
1387 sizeof((sk)->sk_lock)); \
1388 lockdep_set_class_and_name(&(sk)->sk_lock.slock, \
1389 (skey), (sname)); \
1390 lockdep_init_map(&(sk)->sk_lock.dep_map, (name), (key), 0); \
1391} while (0)
1392
1393#ifdef CONFIG_LOCKDEP
1394static inline bool lockdep_sock_is_held(const struct sock *csk)
1395{
1396 struct sock *sk = (struct sock *)csk;
1397
1398 return lockdep_is_held(&sk->sk_lock) ||
1399 lockdep_is_held(&sk->sk_lock.slock);
1400}
1401#endif
1402
1403void lock_sock_nested(struct sock *sk, int subclass);
1404
1405static inline void lock_sock(struct sock *sk)
1406{
1407 lock_sock_nested(sk, 0);
1408}
1409
1410void release_sock(struct sock *sk);
1411
1412
1413#define bh_lock_sock(__sk) spin_lock(&((__sk)->sk_lock.slock))
1414#define bh_lock_sock_nested(__sk) \
1415 spin_lock_nested(&((__sk)->sk_lock.slock), \
1416 SINGLE_DEPTH_NESTING)
1417#define bh_unlock_sock(__sk) spin_unlock(&((__sk)->sk_lock.slock))
1418
1419bool lock_sock_fast(struct sock *sk);
1420
1421
1422
1423
1424
1425
1426
1427
1428static inline void unlock_sock_fast(struct sock *sk, bool slow)
1429{
1430 if (slow)
1431 release_sock(sk);
1432 else
1433 spin_unlock_bh(&sk->sk_lock.slock);
1434}
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450static inline void sock_owned_by_me(const struct sock *sk)
1451{
1452#ifdef CONFIG_LOCKDEP
1453 WARN_ON_ONCE(!lockdep_sock_is_held(sk) && debug_locks);
1454#endif
1455}
1456
1457static inline bool sock_owned_by_user(const struct sock *sk)
1458{
1459 sock_owned_by_me(sk);
1460 return sk->sk_lock.owned;
1461}
1462
1463
1464static inline bool sock_allow_reclassification(const struct sock *csk)
1465{
1466 struct sock *sk = (struct sock *)csk;
1467
1468 return !sk->sk_lock.owned && !spin_is_locked(&sk->sk_lock.slock);
1469}
1470
1471struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
1472 struct proto *prot, int kern);
1473void sk_free(struct sock *sk);
1474void sk_destruct(struct sock *sk);
1475struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority);
1476
1477struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1478 gfp_t priority);
1479void __sock_wfree(struct sk_buff *skb);
1480void sock_wfree(struct sk_buff *skb);
1481void skb_orphan_partial(struct sk_buff *skb);
1482void sock_rfree(struct sk_buff *skb);
1483void sock_efree(struct sk_buff *skb);
1484#ifdef CONFIG_INET
1485void sock_edemux(struct sk_buff *skb);
1486#else
1487#define sock_edemux(skb) sock_efree(skb)
1488#endif
1489
1490int sock_setsockopt(struct socket *sock, int level, int op,
1491 char __user *optval, unsigned int optlen);
1492
1493int sock_getsockopt(struct socket *sock, int level, int op,
1494 char __user *optval, int __user *optlen);
1495struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1496 int noblock, int *errcode);
1497struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1498 unsigned long data_len, int noblock,
1499 int *errcode, int max_page_order);
1500void *sock_kmalloc(struct sock *sk, int size, gfp_t priority);
1501void sock_kfree_s(struct sock *sk, void *mem, int size);
1502void sock_kzfree_s(struct sock *sk, void *mem, int size);
1503void sk_send_sigurg(struct sock *sk);
1504
1505struct sockcm_cookie {
1506 u32 mark;
1507 u16 tsflags;
1508};
1509
1510int __sock_cmsg_send(struct sock *sk, struct msghdr *msg, struct cmsghdr *cmsg,
1511 struct sockcm_cookie *sockc);
1512int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
1513 struct sockcm_cookie *sockc);
1514
1515
1516
1517
1518
1519int sock_no_bind(struct socket *, struct sockaddr *, int);
1520int sock_no_connect(struct socket *, struct sockaddr *, int, int);
1521int sock_no_socketpair(struct socket *, struct socket *);
1522int sock_no_accept(struct socket *, struct socket *, int);
1523int sock_no_getname(struct socket *, struct sockaddr *, int *, int);
1524unsigned int sock_no_poll(struct file *, struct socket *,
1525 struct poll_table_struct *);
1526int sock_no_ioctl(struct socket *, unsigned int, unsigned long);
1527int sock_no_listen(struct socket *, int);
1528int sock_no_shutdown(struct socket *, int);
1529int sock_no_getsockopt(struct socket *, int , int, char __user *, int __user *);
1530int sock_no_setsockopt(struct socket *, int, int, char __user *, unsigned int);
1531int sock_no_sendmsg(struct socket *, struct msghdr *, size_t);
1532int sock_no_recvmsg(struct socket *, struct msghdr *, size_t, int);
1533int sock_no_mmap(struct file *file, struct socket *sock,
1534 struct vm_area_struct *vma);
1535ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset,
1536 size_t size, int flags);
1537
1538
1539
1540
1541
1542int sock_common_getsockopt(struct socket *sock, int level, int optname,
1543 char __user *optval, int __user *optlen);
1544int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1545 int flags);
1546int sock_common_setsockopt(struct socket *sock, int level, int optname,
1547 char __user *optval, unsigned int optlen);
1548int compat_sock_common_getsockopt(struct socket *sock, int level,
1549 int optname, char __user *optval, int __user *optlen);
1550int compat_sock_common_setsockopt(struct socket *sock, int level,
1551 int optname, char __user *optval, unsigned int optlen);
1552
1553void sk_common_release(struct sock *sk);
1554
1555
1556
1557
1558
1559
1560void sock_init_data(struct socket *sock, struct sock *sk);
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588static inline void sock_put(struct sock *sk)
1589{
1590 if (atomic_dec_and_test(&sk->sk_refcnt))
1591 sk_free(sk);
1592}
1593
1594
1595
1596void sock_gen_put(struct sock *sk);
1597
1598int __sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested,
1599 unsigned int trim_cap, bool refcounted);
1600static inline int sk_receive_skb(struct sock *sk, struct sk_buff *skb,
1601 const int nested)
1602{
1603 return __sk_receive_skb(sk, skb, nested, 1, true);
1604}
1605
1606static inline void sk_tx_queue_set(struct sock *sk, int tx_queue)
1607{
1608 sk->sk_tx_queue_mapping = tx_queue;
1609}
1610
1611static inline void sk_tx_queue_clear(struct sock *sk)
1612{
1613 sk->sk_tx_queue_mapping = -1;
1614}
1615
1616static inline int sk_tx_queue_get(const struct sock *sk)
1617{
1618 return sk ? sk->sk_tx_queue_mapping : -1;
1619}
1620
1621static inline void sk_set_socket(struct sock *sk, struct socket *sock)
1622{
1623 sk_tx_queue_clear(sk);
1624 sk->sk_socket = sock;
1625}
1626
1627static inline wait_queue_head_t *sk_sleep(struct sock *sk)
1628{
1629 BUILD_BUG_ON(offsetof(struct socket_wq, wait) != 0);
1630 return &rcu_dereference_raw(sk->sk_wq)->wait;
1631}
1632
1633
1634
1635
1636
1637
1638
1639static inline void sock_orphan(struct sock *sk)
1640{
1641 write_lock_bh(&sk->sk_callback_lock);
1642 sock_set_flag(sk, SOCK_DEAD);
1643 sk_set_socket(sk, NULL);
1644 sk->sk_wq = NULL;
1645 write_unlock_bh(&sk->sk_callback_lock);
1646}
1647
1648static inline void sock_graft(struct sock *sk, struct socket *parent)
1649{
1650 write_lock_bh(&sk->sk_callback_lock);
1651 sk->sk_wq = parent->wq;
1652 parent->sk = sk;
1653 sk_set_socket(sk, parent);
1654 security_sock_graft(sk, parent);
1655 write_unlock_bh(&sk->sk_callback_lock);
1656}
1657
1658kuid_t sock_i_uid(struct sock *sk);
1659unsigned long sock_i_ino(struct sock *sk);
1660
1661static inline u32 net_tx_rndhash(void)
1662{
1663 u32 v = prandom_u32();
1664
1665 return v ?: 1;
1666}
1667
1668static inline void sk_set_txhash(struct sock *sk)
1669{
1670 sk->sk_txhash = net_tx_rndhash();
1671}
1672
1673static inline void sk_rethink_txhash(struct sock *sk)
1674{
1675 if (sk->sk_txhash)
1676 sk_set_txhash(sk);
1677}
1678
1679static inline struct dst_entry *
1680__sk_dst_get(struct sock *sk)
1681{
1682 return rcu_dereference_check(sk->sk_dst_cache,
1683 lockdep_sock_is_held(sk));
1684}
1685
1686static inline struct dst_entry *
1687sk_dst_get(struct sock *sk)
1688{
1689 struct dst_entry *dst;
1690
1691 rcu_read_lock();
1692 dst = rcu_dereference(sk->sk_dst_cache);
1693 if (dst && !atomic_inc_not_zero(&dst->__refcnt))
1694 dst = NULL;
1695 rcu_read_unlock();
1696 return dst;
1697}
1698
1699static inline void dst_negative_advice(struct sock *sk)
1700{
1701 struct dst_entry *ndst, *dst = __sk_dst_get(sk);
1702
1703 sk_rethink_txhash(sk);
1704
1705 if (dst && dst->ops->negative_advice) {
1706 ndst = dst->ops->negative_advice(dst);
1707
1708 if (ndst != dst) {
1709 rcu_assign_pointer(sk->sk_dst_cache, ndst);
1710 sk_tx_queue_clear(sk);
1711 }
1712 }
1713}
1714
1715static inline void
1716__sk_dst_set(struct sock *sk, struct dst_entry *dst)
1717{
1718 struct dst_entry *old_dst;
1719
1720 sk_tx_queue_clear(sk);
1721
1722
1723
1724
1725 old_dst = rcu_dereference_raw(sk->sk_dst_cache);
1726 rcu_assign_pointer(sk->sk_dst_cache, dst);
1727 dst_release(old_dst);
1728}
1729
1730static inline void
1731sk_dst_set(struct sock *sk, struct dst_entry *dst)
1732{
1733 struct dst_entry *old_dst;
1734
1735 sk_tx_queue_clear(sk);
1736 old_dst = xchg((__force struct dst_entry **)&sk->sk_dst_cache, dst);
1737 dst_release(old_dst);
1738}
1739
1740static inline void
1741__sk_dst_reset(struct sock *sk)
1742{
1743 __sk_dst_set(sk, NULL);
1744}
1745
1746static inline void
1747sk_dst_reset(struct sock *sk)
1748{
1749 sk_dst_set(sk, NULL);
1750}
1751
1752struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie);
1753
1754struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie);
1755
1756bool sk_mc_loop(struct sock *sk);
1757
1758static inline bool sk_can_gso(const struct sock *sk)
1759{
1760 return net_gso_ok(sk->sk_route_caps, sk->sk_gso_type);
1761}
1762
1763void sk_setup_caps(struct sock *sk, struct dst_entry *dst);
1764
1765static inline void sk_nocaps_add(struct sock *sk, netdev_features_t flags)
1766{
1767 sk->sk_route_nocaps |= flags;
1768 sk->sk_route_caps &= ~flags;
1769}
1770
1771static inline bool sk_check_csum_caps(struct sock *sk)
1772{
1773 return (sk->sk_route_caps & NETIF_F_HW_CSUM) ||
1774 (sk->sk_family == PF_INET &&
1775 (sk->sk_route_caps & NETIF_F_IP_CSUM)) ||
1776 (sk->sk_family == PF_INET6 &&
1777 (sk->sk_route_caps & NETIF_F_IPV6_CSUM));
1778}
1779
1780static inline int skb_do_copy_data_nocache(struct sock *sk, struct sk_buff *skb,
1781 struct iov_iter *from, char *to,
1782 int copy, int offset)
1783{
1784 if (skb->ip_summed == CHECKSUM_NONE) {
1785 __wsum csum = 0;
1786 if (csum_and_copy_from_iter(to, copy, &csum, from) != copy)
1787 return -EFAULT;
1788 skb->csum = csum_block_add(skb->csum, csum, offset);
1789 } else if (sk->sk_route_caps & NETIF_F_NOCACHE_COPY) {
1790 if (copy_from_iter_nocache(to, copy, from) != copy)
1791 return -EFAULT;
1792 } else if (copy_from_iter(to, copy, from) != copy)
1793 return -EFAULT;
1794
1795 return 0;
1796}
1797
1798static inline int skb_add_data_nocache(struct sock *sk, struct sk_buff *skb,
1799 struct iov_iter *from, int copy)
1800{
1801 int err, offset = skb->len;
1802
1803 err = skb_do_copy_data_nocache(sk, skb, from, skb_put(skb, copy),
1804 copy, offset);
1805 if (err)
1806 __skb_trim(skb, offset);
1807
1808 return err;
1809}
1810
1811static inline int skb_copy_to_page_nocache(struct sock *sk, struct iov_iter *from,
1812 struct sk_buff *skb,
1813 struct page *page,
1814 int off, int copy)
1815{
1816 int err;
1817
1818 err = skb_do_copy_data_nocache(sk, skb, from, page_address(page) + off,
1819 copy, skb->len);
1820 if (err)
1821 return err;
1822
1823 skb->len += copy;
1824 skb->data_len += copy;
1825 skb->truesize += copy;
1826 sk->sk_wmem_queued += copy;
1827 sk_mem_charge(sk, copy);
1828 return 0;
1829}
1830
1831
1832
1833
1834
1835
1836
1837static inline int sk_wmem_alloc_get(const struct sock *sk)
1838{
1839 return atomic_read(&sk->sk_wmem_alloc) - 1;
1840}
1841
1842
1843
1844
1845
1846
1847
1848static inline int sk_rmem_alloc_get(const struct sock *sk)
1849{
1850 return atomic_read(&sk->sk_rmem_alloc);
1851}
1852
1853
1854
1855
1856
1857
1858
1859static inline bool sk_has_allocations(const struct sock *sk)
1860{
1861 return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
1862}
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896static inline bool skwq_has_sleeper(struct socket_wq *wq)
1897{
1898 return wq && wq_has_sleeper(&wq->wait);
1899}
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909static inline void sock_poll_wait(struct file *filp,
1910 wait_queue_head_t *wait_address, poll_table *p)
1911{
1912 if (!poll_does_not_wait(p) && wait_address) {
1913 poll_wait(filp, wait_address, p);
1914
1915
1916
1917
1918
1919 smp_mb();
1920 }
1921}
1922
1923static inline void skb_set_hash_from_sk(struct sk_buff *skb, struct sock *sk)
1924{
1925 if (sk->sk_txhash) {
1926 skb->l4_hash = 1;
1927 skb->hash = sk->sk_txhash;
1928 }
1929}
1930
1931void skb_set_owner_w(struct sk_buff *skb, struct sock *sk);
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
1942{
1943 skb_orphan(skb);
1944 skb->sk = sk;
1945 skb->destructor = sock_rfree;
1946 atomic_add(skb->truesize, &sk->sk_rmem_alloc);
1947 sk_mem_charge(sk, skb->truesize);
1948}
1949
1950void sk_reset_timer(struct sock *sk, struct timer_list *timer,
1951 unsigned long expires);
1952
1953void sk_stop_timer(struct sock *sk, struct timer_list *timer);
1954
1955int __sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
1956int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
1957
1958int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb);
1959struct sk_buff *sock_dequeue_err_skb(struct sock *sk);
1960
1961
1962
1963
1964
1965static inline int sock_error(struct sock *sk)
1966{
1967 int err;
1968 if (likely(!sk->sk_err))
1969 return 0;
1970 err = xchg(&sk->sk_err, 0);
1971 return -err;
1972}
1973
1974static inline unsigned long sock_wspace(struct sock *sk)
1975{
1976 int amt = 0;
1977
1978 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
1979 amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1980 if (amt < 0)
1981 amt = 0;
1982 }
1983 return amt;
1984}
1985
1986
1987
1988
1989
1990static inline void sk_set_bit(int nr, struct sock *sk)
1991{
1992 if ((nr == SOCKWQ_ASYNC_NOSPACE || nr == SOCKWQ_ASYNC_WAITDATA) &&
1993 !sock_flag(sk, SOCK_FASYNC))
1994 return;
1995
1996 set_bit(nr, &sk->sk_wq_raw->flags);
1997}
1998
1999static inline void sk_clear_bit(int nr, struct sock *sk)
2000{
2001 if ((nr == SOCKWQ_ASYNC_NOSPACE || nr == SOCKWQ_ASYNC_WAITDATA) &&
2002 !sock_flag(sk, SOCK_FASYNC))
2003 return;
2004
2005 clear_bit(nr, &sk->sk_wq_raw->flags);
2006}
2007
2008static inline void sk_wake_async(const struct sock *sk, int how, int band)
2009{
2010 if (sock_flag(sk, SOCK_FASYNC)) {
2011 rcu_read_lock();
2012 sock_wake_async(rcu_dereference(sk->sk_wq), how, band);
2013 rcu_read_unlock();
2014 }
2015}
2016
2017
2018
2019
2020
2021
2022#define TCP_SKB_MIN_TRUESIZE (2048 + SKB_DATA_ALIGN(sizeof(struct sk_buff)))
2023
2024#define SOCK_MIN_SNDBUF (TCP_SKB_MIN_TRUESIZE * 2)
2025#define SOCK_MIN_RCVBUF TCP_SKB_MIN_TRUESIZE
2026
2027static inline void sk_stream_moderate_sndbuf(struct sock *sk)
2028{
2029 if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
2030 sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
2031 sk->sk_sndbuf = max_t(u32, sk->sk_sndbuf, SOCK_MIN_SNDBUF);
2032 }
2033}
2034
2035struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp,
2036 bool force_schedule);
2037
2038
2039
2040
2041
2042
2043
2044
2045static inline struct page_frag *sk_page_frag(struct sock *sk)
2046{
2047 if (gfpflags_allow_blocking(sk->sk_allocation))
2048 return ¤t->task_frag;
2049
2050 return &sk->sk_frag;
2051}
2052
2053bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag);
2054
2055
2056
2057
2058static inline bool sock_writeable(const struct sock *sk)
2059{
2060 return atomic_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);
2061}
2062
2063static inline gfp_t gfp_any(void)
2064{
2065 return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
2066}
2067
2068static inline long sock_rcvtimeo(const struct sock *sk, bool noblock)
2069{
2070 return noblock ? 0 : sk->sk_rcvtimeo;
2071}
2072
2073static inline long sock_sndtimeo(const struct sock *sk, bool noblock)
2074{
2075 return noblock ? 0 : sk->sk_sndtimeo;
2076}
2077
2078static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
2079{
2080 return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;
2081}
2082
2083
2084
2085
2086static inline int sock_intr_errno(long timeo)
2087{
2088 return timeo == MAX_SCHEDULE_TIMEOUT ? -ERESTARTSYS : -EINTR;
2089}
2090
2091struct sock_skb_cb {
2092 u32 dropcount;
2093};
2094
2095
2096
2097
2098
2099#define SOCK_SKB_CB_OFFSET ((FIELD_SIZEOF(struct sk_buff, cb) - \
2100 sizeof(struct sock_skb_cb)))
2101
2102#define SOCK_SKB_CB(__skb) ((struct sock_skb_cb *)((__skb)->cb + \
2103 SOCK_SKB_CB_OFFSET))
2104
2105#define sock_skb_cb_check_size(size) \
2106 BUILD_BUG_ON((size) > SOCK_SKB_CB_OFFSET)
2107
2108static inline void
2109sock_skb_set_dropcount(const struct sock *sk, struct sk_buff *skb)
2110{
2111 SOCK_SKB_CB(skb)->dropcount = atomic_read(&sk->sk_drops);
2112}
2113
2114static inline void sk_drops_add(struct sock *sk, const struct sk_buff *skb)
2115{
2116 int segs = max_t(u16, 1, skb_shinfo(skb)->gso_segs);
2117
2118 atomic_add(segs, &sk->sk_drops);
2119}
2120
2121void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
2122 struct sk_buff *skb);
2123void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
2124 struct sk_buff *skb);
2125
2126static inline void
2127sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
2128{
2129 ktime_t kt = skb->tstamp;
2130 struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
2131
2132
2133
2134
2135
2136
2137
2138 if (sock_flag(sk, SOCK_RCVTSTAMP) ||
2139 (sk->sk_tsflags & SOF_TIMESTAMPING_RX_SOFTWARE) ||
2140 (kt.tv64 && sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) ||
2141 (hwtstamps->hwtstamp.tv64 &&
2142 (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE)))
2143 __sock_recv_timestamp(msg, sk, skb);
2144 else
2145 sk->sk_stamp = kt;
2146
2147 if (sock_flag(sk, SOCK_WIFI_STATUS) && skb->wifi_acked_valid)
2148 __sock_recv_wifi_status(msg, sk, skb);
2149}
2150
2151void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
2152 struct sk_buff *skb);
2153
2154static inline void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
2155 struct sk_buff *skb)
2156{
2157#define FLAGS_TS_OR_DROPS ((1UL << SOCK_RXQ_OVFL) | \
2158 (1UL << SOCK_RCVTSTAMP))
2159#define TSFLAGS_ANY (SOF_TIMESTAMPING_SOFTWARE | \
2160 SOF_TIMESTAMPING_RAW_HARDWARE)
2161
2162 if (sk->sk_flags & FLAGS_TS_OR_DROPS || sk->sk_tsflags & TSFLAGS_ANY)
2163 __sock_recv_ts_and_drops(msg, sk, skb);
2164 else
2165 sk->sk_stamp = skb->tstamp;
2166}
2167
2168void __sock_tx_timestamp(__u16 tsflags, __u8 *tx_flags);
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178static inline void sock_tx_timestamp(const struct sock *sk, __u16 tsflags,
2179 __u8 *tx_flags)
2180{
2181 if (unlikely(tsflags))
2182 __sock_tx_timestamp(tsflags, tx_flags);
2183 if (unlikely(sock_flag(sk, SOCK_WIFI_STATUS)))
2184 *tx_flags |= SKBTX_WIFI_STATUS;
2185}
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb)
2196{
2197 __skb_unlink(skb, &sk->sk_receive_queue);
2198 __kfree_skb(skb);
2199}
2200
2201static inline
2202struct net *sock_net(const struct sock *sk)
2203{
2204 return read_pnet(&sk->sk_net);
2205}
2206
2207static inline
2208void sock_net_set(struct sock *sk, struct net *net)
2209{
2210 write_pnet(&sk->sk_net, net);
2211}
2212
2213static inline struct sock *skb_steal_sock(struct sk_buff *skb)
2214{
2215 if (skb->sk) {
2216 struct sock *sk = skb->sk;
2217
2218 skb->destructor = NULL;
2219 skb->sk = NULL;
2220 return sk;
2221 }
2222 return NULL;
2223}
2224
2225
2226
2227
2228static inline bool sk_fullsock(const struct sock *sk)
2229{
2230 return (1 << sk->sk_state) & ~(TCPF_TIME_WAIT | TCPF_NEW_SYN_RECV);
2231}
2232
2233
2234
2235
2236static inline bool sk_listener(const struct sock *sk)
2237{
2238 return (1 << sk->sk_state) & (TCPF_LISTEN | TCPF_NEW_SYN_RECV);
2239}
2240
2241
2242
2243
2244
2245
2246
2247
2248static inline int sk_state_load(const struct sock *sk)
2249{
2250 return smp_load_acquire(&sk->sk_state);
2251}
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261static inline void sk_state_store(struct sock *sk, int newstate)
2262{
2263 smp_store_release(&sk->sk_state, newstate);
2264}
2265
2266void sock_enable_timestamp(struct sock *sk, int flag);
2267int sock_get_timestamp(struct sock *, struct timeval __user *);
2268int sock_get_timestampns(struct sock *, struct timespec __user *);
2269int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len, int level,
2270 int type);
2271
2272bool sk_ns_capable(const struct sock *sk,
2273 struct user_namespace *user_ns, int cap);
2274bool sk_capable(const struct sock *sk, int cap);
2275bool sk_net_capable(const struct sock *sk, int cap);
2276
2277extern __u32 sysctl_wmem_max;
2278extern __u32 sysctl_rmem_max;
2279
2280extern int sysctl_tstamp_allow_data;
2281extern int sysctl_optmem_max;
2282
2283extern __u32 sysctl_wmem_default;
2284extern __u32 sysctl_rmem_default;
2285
2286#endif
2287