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