~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/net/request_sock.h

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * NET          Generic infrastructure for Network protocols.
  3  *
  4  *              Definitions for request_sock 
  5  *
  6  * Authors:     Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  7  *
  8  *              From code originally in include/net/tcp.h
  9  *
 10  *              This program is free software; you can redistribute it and/or
 11  *              modify it under the terms of the GNU General Public License
 12  *              as published by the Free Software Foundation; either version
 13  *              2 of the License, or (at your option) any later version.
 14  */
 15 #ifndef _REQUEST_SOCK_H
 16 #define _REQUEST_SOCK_H
 17 
 18 #include <linux/slab.h>
 19 #include <linux/spinlock.h>
 20 #include <linux/types.h>
 21 #include <linux/bug.h>
 22 
 23 #include <net/sock.h>
 24 
 25 struct request_sock;
 26 struct sk_buff;
 27 struct dst_entry;
 28 struct proto;
 29 
 30 struct request_sock_ops {
 31         int             family;
 32         int             obj_size;
 33         struct kmem_cache       *slab;
 34         char            *slab_name;
 35         int             (*rtx_syn_ack)(struct sock *sk,
 36                                        struct request_sock *req);
 37         void            (*send_ack)(struct sock *sk, struct sk_buff *skb,
 38                                     struct request_sock *req);
 39         void            (*send_reset)(struct sock *sk,
 40                                       struct sk_buff *skb);
 41         void            (*destructor)(struct request_sock *req);
 42         void            (*syn_ack_timeout)(const struct request_sock *req);
 43 };
 44 
 45 int inet_rtx_syn_ack(struct sock *parent, struct request_sock *req);
 46 
 47 /* struct request_sock - mini sock to represent a connection request
 48  */
 49 struct request_sock {
 50         struct sock_common              __req_common;
 51 #define rsk_refcnt                      __req_common.skc_refcnt
 52 #define rsk_hash                        __req_common.skc_hash
 53 
 54         struct request_sock             *dl_next;
 55         struct sock                     *rsk_listener;
 56         u16                             mss;
 57         u8                              num_retrans; /* number of retransmits */
 58         u8                              cookie_ts:1; /* syncookie: encode tcpopts in timestamp */
 59         u8                              num_timeout:7; /* number of timeouts */
 60         /* The following two fields can be easily recomputed I think -AK */
 61         u32                             window_clamp; /* window clamp at creation time */
 62         u32                             rcv_wnd;          /* rcv_wnd offered first time */
 63         u32                             ts_recent;
 64         struct timer_list               rsk_timer;
 65         const struct request_sock_ops   *rsk_ops;
 66         struct sock                     *sk;
 67         u32                             *saved_syn;
 68         u32                             secid;
 69         u32                             peer_secid;
 70 };
 71 
 72 static inline struct request_sock *
 73 reqsk_alloc(const struct request_sock_ops *ops, struct sock *sk_listener)
 74 {
 75         struct request_sock *req = kmem_cache_alloc(ops->slab, GFP_ATOMIC);
 76 
 77         if (req) {
 78                 req->rsk_ops = ops;
 79                 sock_hold(sk_listener);
 80                 req->rsk_listener = sk_listener;
 81                 req->saved_syn = NULL;
 82                 /* Following is temporary. It is coupled with debugging
 83                  * helpers in reqsk_put() & reqsk_free()
 84                  */
 85                 atomic_set(&req->rsk_refcnt, 0);
 86         }
 87         return req;
 88 }
 89 
 90 static inline struct request_sock *inet_reqsk(struct sock *sk)
 91 {
 92         return (struct request_sock *)sk;
 93 }
 94 
 95 static inline struct sock *req_to_sk(struct request_sock *req)
 96 {
 97         return (struct sock *)req;
 98 }
 99 
100 static inline void reqsk_free(struct request_sock *req)
101 {
102         /* temporary debugging */
103         WARN_ON_ONCE(atomic_read(&req->rsk_refcnt) != 0);
104 
105         req->rsk_ops->destructor(req);
106         if (req->rsk_listener)
107                 sock_put(req->rsk_listener);
108         kfree(req->saved_syn);
109         kmem_cache_free(req->rsk_ops->slab, req);
110 }
111 
112 static inline void reqsk_put(struct request_sock *req)
113 {
114         if (atomic_dec_and_test(&req->rsk_refcnt))
115                 reqsk_free(req);
116 }
117 
118 extern int sysctl_max_syn_backlog;
119 
120 /** struct listen_sock - listen state
121  *
122  * @max_qlen_log - log_2 of maximal queued SYNs/REQUESTs
123  */
124 struct listen_sock {
125         int                     qlen_inc; /* protected by listener lock */
126         int                     young_inc;/* protected by listener lock */
127 
128         /* following fields can be updated by timer */
129         atomic_t                qlen_dec; /* qlen = qlen_inc - qlen_dec */
130         atomic_t                young_dec;
131 
132         u8                      max_qlen_log ____cacheline_aligned_in_smp;
133         u8                      synflood_warned;
134         /* 2 bytes hole, try to use */
135         u32                     hash_rnd;
136         u32                     nr_table_entries;
137         struct request_sock     *syn_table[0];
138 };
139 
140 /*
141  * For a TCP Fast Open listener -
142  *      lock - protects the access to all the reqsk, which is co-owned by
143  *              the listener and the child socket.
144  *      qlen - pending TFO requests (still in TCP_SYN_RECV).
145  *      max_qlen - max TFO reqs allowed before TFO is disabled.
146  *
147  *      XXX (TFO) - ideally these fields can be made as part of "listen_sock"
148  *      structure above. But there is some implementation difficulty due to
149  *      listen_sock being part of request_sock_queue hence will be freed when
150  *      a listener is stopped. But TFO related fields may continue to be
151  *      accessed even after a listener is closed, until its sk_refcnt drops
152  *      to 0 implying no more outstanding TFO reqs. One solution is to keep
153  *      listen_opt around until sk_refcnt drops to 0. But there is some other
154  *      complexity that needs to be resolved. E.g., a listener can be disabled
155  *      temporarily through shutdown()->tcp_disconnect(), and re-enabled later.
156  */
157 struct fastopen_queue {
158         struct request_sock     *rskq_rst_head; /* Keep track of past TFO */
159         struct request_sock     *rskq_rst_tail; /* requests that caused RST.
160                                                  * This is part of the defense
161                                                  * against spoofing attack.
162                                                  */
163         spinlock_t      lock;
164         int             qlen;           /* # of pending (TCP_SYN_RECV) reqs */
165         int             max_qlen;       /* != 0 iff TFO is currently enabled */
166 };
167 
168 /** struct request_sock_queue - queue of request_socks
169  *
170  * @rskq_accept_head - FIFO head of established children
171  * @rskq_accept_tail - FIFO tail of established children
172  * @rskq_defer_accept - User waits for some data after accept()
173  * @syn_wait_lock - serializer
174  *
175  * %syn_wait_lock is necessary only to avoid proc interface having to grab the main
176  * lock sock while browsing the listening hash (otherwise it's deadlock prone).
177  *
178  */
179 struct request_sock_queue {
180         struct request_sock     *rskq_accept_head;
181         struct request_sock     *rskq_accept_tail;
182         u8                      rskq_defer_accept;
183         struct listen_sock      *listen_opt;
184         struct fastopen_queue   *fastopenq; /* This is non-NULL iff TFO has been
185                                              * enabled on this listener. Check
186                                              * max_qlen != 0 in fastopen_queue
187                                              * to determine if TFO is enabled
188                                              * right at this moment.
189                                              */
190 
191         /* temporary alignment, our goal is to get rid of this lock */
192         spinlock_t              syn_wait_lock ____cacheline_aligned_in_smp;
193 };
194 
195 int reqsk_queue_alloc(struct request_sock_queue *queue,
196                       unsigned int nr_table_entries);
197 
198 void __reqsk_queue_destroy(struct request_sock_queue *queue);
199 void reqsk_queue_destroy(struct request_sock_queue *queue);
200 void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req,
201                            bool reset);
202 
203 static inline struct request_sock *
204         reqsk_queue_yank_acceptq(struct request_sock_queue *queue)
205 {
206         struct request_sock *req = queue->rskq_accept_head;
207 
208         queue->rskq_accept_head = NULL;
209         return req;
210 }
211 
212 static inline int reqsk_queue_empty(struct request_sock_queue *queue)
213 {
214         return queue->rskq_accept_head == NULL;
215 }
216 
217 static inline void reqsk_queue_add(struct request_sock_queue *queue,
218                                    struct request_sock *req,
219                                    struct sock *parent,
220                                    struct sock *child)
221 {
222         req->sk = child;
223         sk_acceptq_added(parent);
224 
225         if (queue->rskq_accept_head == NULL)
226                 queue->rskq_accept_head = req;
227         else
228                 queue->rskq_accept_tail->dl_next = req;
229 
230         queue->rskq_accept_tail = req;
231         req->dl_next = NULL;
232 }
233 
234 static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue)
235 {
236         struct request_sock *req = queue->rskq_accept_head;
237 
238         WARN_ON(req == NULL);
239 
240         queue->rskq_accept_head = req->dl_next;
241         if (queue->rskq_accept_head == NULL)
242                 queue->rskq_accept_tail = NULL;
243 
244         return req;
245 }
246 
247 static inline void reqsk_queue_removed(struct request_sock_queue *queue,
248                                        const struct request_sock *req)
249 {
250         struct listen_sock *lopt = queue->listen_opt;
251 
252         if (req->num_timeout == 0)
253                 atomic_inc(&lopt->young_dec);
254         atomic_inc(&lopt->qlen_dec);
255 }
256 
257 static inline void reqsk_queue_added(struct request_sock_queue *queue)
258 {
259         struct listen_sock *lopt = queue->listen_opt;
260 
261         lopt->young_inc++;
262         lopt->qlen_inc++;
263 }
264 
265 static inline int listen_sock_qlen(const struct listen_sock *lopt)
266 {
267         return lopt->qlen_inc - atomic_read(&lopt->qlen_dec);
268 }
269 
270 static inline int listen_sock_young(const struct listen_sock *lopt)
271 {
272         return lopt->young_inc - atomic_read(&lopt->young_dec);
273 }
274 
275 static inline int reqsk_queue_len(const struct request_sock_queue *queue)
276 {
277         const struct listen_sock *lopt = queue->listen_opt;
278 
279         return lopt ? listen_sock_qlen(lopt) : 0;
280 }
281 
282 static inline int reqsk_queue_len_young(const struct request_sock_queue *queue)
283 {
284         return listen_sock_young(queue->listen_opt);
285 }
286 
287 static inline int reqsk_queue_is_full(const struct request_sock_queue *queue)
288 {
289         return reqsk_queue_len(queue) >> queue->listen_opt->max_qlen_log;
290 }
291 
292 void reqsk_queue_hash_req(struct request_sock_queue *queue,
293                           u32 hash, struct request_sock *req,
294                           unsigned long timeout);
295 
296 #endif /* _REQUEST_SOCK_H */
297 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp