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