[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
/*
|
|
|
|
* NET Generic infrastructure for Network protocols.
|
|
|
|
*
|
|
|
|
* Definitions for request_sock
|
|
|
|
*
|
|
|
|
* Authors: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
|
|
|
|
*
|
|
|
|
* From code originally in include/net/tcp.h
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
#ifndef _REQUEST_SOCK_H
|
|
|
|
#define _REQUEST_SOCK_H
|
|
|
|
|
|
|
|
#include <linux/slab.h>
|
2005-06-18 23:47:59 -06:00
|
|
|
#include <linux/spinlock.h>
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
#include <linux/types.h>
|
2008-07-25 22:43:18 -06:00
|
|
|
#include <linux/bug.h>
|
2005-06-18 23:47:59 -06:00
|
|
|
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
#include <net/sock.h>
|
|
|
|
|
2005-06-18 23:47:21 -06:00
|
|
|
struct request_sock;
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
struct sk_buff;
|
|
|
|
struct dst_entry;
|
|
|
|
struct proto;
|
|
|
|
|
2005-06-18 23:47:21 -06:00
|
|
|
struct request_sock_ops {
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
int family;
|
|
|
|
int obj_size;
|
2006-12-06 21:33:20 -07:00
|
|
|
struct kmem_cache *slab;
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
int (*rtx_syn_ack)(struct sock *sk,
|
2008-02-29 12:43:03 -07:00
|
|
|
struct request_sock *req);
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
void (*send_ack)(struct sk_buff *skb,
|
2005-06-18 23:47:21 -06:00
|
|
|
struct request_sock *req);
|
2006-11-14 20:07:45 -07:00
|
|
|
void (*send_reset)(struct sock *sk,
|
|
|
|
struct sk_buff *skb);
|
2005-06-18 23:47:21 -06:00
|
|
|
void (*destructor)(struct request_sock *req);
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
};
|
|
|
|
|
2005-06-18 23:47:21 -06:00
|
|
|
/* struct request_sock - mini sock to represent a connection request
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
*/
|
2005-06-18 23:47:21 -06:00
|
|
|
struct request_sock {
|
|
|
|
struct request_sock *dl_next; /* Must be first member! */
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
u16 mss;
|
|
|
|
u8 retrans;
|
2008-04-10 04:12:40 -06:00
|
|
|
u8 cookie_ts; /* syncookie: encode tcpopts in timestamp */
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
/* The following two fields can be easily recomputed I think -AK */
|
|
|
|
u32 window_clamp; /* window clamp at creation time */
|
|
|
|
u32 rcv_wnd; /* rcv_wnd offered first time */
|
|
|
|
u32 ts_recent;
|
|
|
|
unsigned long expires;
|
2006-11-16 03:30:37 -07:00
|
|
|
const struct request_sock_ops *rsk_ops;
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
struct sock *sk;
|
2006-07-25 00:32:50 -06:00
|
|
|
u32 secid;
|
2006-11-08 16:04:09 -07:00
|
|
|
u32 peer_secid;
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
};
|
|
|
|
|
2006-11-16 03:30:37 -07:00
|
|
|
static inline struct request_sock *reqsk_alloc(const struct request_sock_ops *ops)
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
{
|
2006-12-06 21:33:16 -07:00
|
|
|
struct request_sock *req = kmem_cache_alloc(ops->slab, GFP_ATOMIC);
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
|
|
|
|
if (req != NULL)
|
2005-06-18 23:47:21 -06:00
|
|
|
req->rsk_ops = ops;
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
2005-06-18 23:47:21 -06:00
|
|
|
static inline void __reqsk_free(struct request_sock *req)
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
{
|
2005-06-18 23:47:21 -06:00
|
|
|
kmem_cache_free(req->rsk_ops->slab, req);
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
}
|
|
|
|
|
2005-06-18 23:47:21 -06:00
|
|
|
static inline void reqsk_free(struct request_sock *req)
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
{
|
2005-06-18 23:47:21 -06:00
|
|
|
req->rsk_ops->destructor(req);
|
|
|
|
__reqsk_free(req);
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
}
|
|
|
|
|
2005-06-18 23:47:59 -06:00
|
|
|
extern int sysctl_max_syn_backlog;
|
|
|
|
|
2005-06-18 23:48:55 -06:00
|
|
|
/** struct listen_sock - listen state
|
2005-06-18 23:47:59 -06:00
|
|
|
*
|
|
|
|
* @max_qlen_log - log_2 of maximal queued SYNs/REQUESTs
|
|
|
|
*/
|
2005-06-18 23:48:55 -06:00
|
|
|
struct listen_sock {
|
2005-06-18 23:47:59 -06:00
|
|
|
u8 max_qlen_log;
|
|
|
|
/* 3 bytes hole, try to use */
|
|
|
|
int qlen;
|
|
|
|
int qlen_young;
|
|
|
|
int clock_hand;
|
|
|
|
u32 hash_rnd;
|
2005-08-09 20:33:31 -06:00
|
|
|
u32 nr_table_entries;
|
2005-06-18 23:47:59 -06:00
|
|
|
struct request_sock *syn_table[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
/** struct request_sock_queue - queue of request_socks
|
|
|
|
*
|
|
|
|
* @rskq_accept_head - FIFO head of established children
|
|
|
|
* @rskq_accept_tail - FIFO tail of established children
|
2005-08-09 21:11:56 -06:00
|
|
|
* @rskq_defer_accept - User waits for some data after accept()
|
2005-06-18 23:47:59 -06:00
|
|
|
* @syn_wait_lock - serializer
|
|
|
|
*
|
|
|
|
* %syn_wait_lock is necessary only to avoid proc interface having to grab the main
|
|
|
|
* lock sock while browsing the listening hash (otherwise it's deadlock prone).
|
|
|
|
*
|
|
|
|
* This lock is acquired in read mode only from listening_get_next() seq_file
|
|
|
|
* op and it's acquired in write mode _only_ from code that is actively
|
|
|
|
* changing rskq_accept_head. All readers that are holding the master sock lock
|
|
|
|
* don't need to grab this lock in read mode too as rskq_accept_head. writes
|
|
|
|
* are always protected from the main sock lock.
|
|
|
|
*/
|
|
|
|
struct request_sock_queue {
|
|
|
|
struct request_sock *rskq_accept_head;
|
|
|
|
struct request_sock *rskq_accept_tail;
|
|
|
|
rwlock_t syn_wait_lock;
|
tcp: Revert 'process defer accept as established' changes.
This reverts two changesets, ec3c0982a2dd1e671bad8e9d26c28dcba0039d87
("[TCP]: TCP_DEFER_ACCEPT updates - process as established") and
the follow-on bug fix 9ae27e0adbf471c7a6b80102e38e1d5a346b3b38
("tcp: Fix slab corruption with ipv6 and tcp6fuzz").
This change causes several problems, first reported by Ingo Molnar
as a distcc-over-loopback regression where connections were getting
stuck.
Ilpo Järvinen first spotted the locking problems. The new function
added by this code, tcp_defer_accept_check(), only has the
child socket locked, yet it is modifying state of the parent
listening socket.
Fixing that is non-trivial at best, because we can't simply just grab
the parent listening socket lock at this point, because it would
create an ABBA deadlock. The normal ordering is parent listening
socket --> child socket, but this code path would require the
reverse lock ordering.
Next is a problem noticed by Vitaliy Gusev, he noted:
----------------------------------------
>--- a/net/ipv4/tcp_timer.c
>+++ b/net/ipv4/tcp_timer.c
>@@ -481,6 +481,11 @@ static void tcp_keepalive_timer (unsigned long data)
> goto death;
> }
>
>+ if (tp->defer_tcp_accept.request && sk->sk_state == TCP_ESTABLISHED) {
>+ tcp_send_active_reset(sk, GFP_ATOMIC);
>+ goto death;
Here socket sk is not attached to listening socket's request queue. tcp_done()
will not call inet_csk_destroy_sock() (and tcp_v4_destroy_sock() which should
release this sk) as socket is not DEAD. Therefore socket sk will be lost for
freeing.
----------------------------------------
Finally, Alexey Kuznetsov argues that there might not even be any
real value or advantage to these new semantics even if we fix all
of the bugs:
----------------------------------------
Hiding from accept() sockets with only out-of-order data only
is the only thing which is impossible with old approach. Is this really
so valuable? My opinion: no, this is nothing but a new loophole
to consume memory without control.
----------------------------------------
So revert this thing for now.
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-06-12 17:31:35 -06:00
|
|
|
u8 rskq_defer_accept;
|
|
|
|
/* 3 bytes hole, try to pack */
|
2005-06-18 23:48:55 -06:00
|
|
|
struct listen_sock *listen_opt;
|
2005-06-18 23:47:59 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
extern int reqsk_queue_alloc(struct request_sock_queue *queue,
|
2006-11-16 03:30:37 -07:00
|
|
|
unsigned int nr_table_entries);
|
2005-06-18 23:47:59 -06:00
|
|
|
|
2007-11-15 03:57:06 -07:00
|
|
|
extern void __reqsk_queue_destroy(struct request_sock_queue *queue);
|
2005-08-09 20:33:31 -06:00
|
|
|
extern void reqsk_queue_destroy(struct request_sock_queue *queue);
|
|
|
|
|
2005-06-18 23:47:59 -06:00
|
|
|
static inline struct request_sock *
|
|
|
|
reqsk_queue_yank_acceptq(struct request_sock_queue *queue)
|
|
|
|
{
|
|
|
|
struct request_sock *req = queue->rskq_accept_head;
|
|
|
|
|
2006-03-26 18:39:55 -07:00
|
|
|
queue->rskq_accept_head = NULL;
|
2005-06-18 23:47:59 -06:00
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int reqsk_queue_empty(struct request_sock_queue *queue)
|
|
|
|
{
|
|
|
|
return queue->rskq_accept_head == NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void reqsk_queue_unlink(struct request_sock_queue *queue,
|
|
|
|
struct request_sock *req,
|
|
|
|
struct request_sock **prev_req)
|
|
|
|
{
|
|
|
|
write_lock(&queue->syn_wait_lock);
|
|
|
|
*prev_req = req->dl_next;
|
|
|
|
write_unlock(&queue->syn_wait_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void reqsk_queue_add(struct request_sock_queue *queue,
|
|
|
|
struct request_sock *req,
|
|
|
|
struct sock *parent,
|
|
|
|
struct sock *child)
|
|
|
|
{
|
|
|
|
req->sk = child;
|
|
|
|
sk_acceptq_added(parent);
|
|
|
|
|
|
|
|
if (queue->rskq_accept_head == NULL)
|
|
|
|
queue->rskq_accept_head = req;
|
|
|
|
else
|
|
|
|
queue->rskq_accept_tail->dl_next = req;
|
|
|
|
|
|
|
|
queue->rskq_accept_tail = req;
|
|
|
|
req->dl_next = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue)
|
|
|
|
{
|
|
|
|
struct request_sock *req = queue->rskq_accept_head;
|
|
|
|
|
2008-07-25 22:43:18 -06:00
|
|
|
WARN_ON(req == NULL);
|
2005-06-18 23:47:59 -06:00
|
|
|
|
|
|
|
queue->rskq_accept_head = req->dl_next;
|
|
|
|
if (queue->rskq_accept_head == NULL)
|
|
|
|
queue->rskq_accept_tail = NULL;
|
|
|
|
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct sock *reqsk_queue_get_child(struct request_sock_queue *queue,
|
|
|
|
struct sock *parent)
|
|
|
|
{
|
|
|
|
struct request_sock *req = reqsk_queue_remove(queue);
|
|
|
|
struct sock *child = req->sk;
|
|
|
|
|
2008-07-25 22:43:18 -06:00
|
|
|
WARN_ON(child == NULL);
|
2005-06-18 23:47:59 -06:00
|
|
|
|
|
|
|
sk_acceptq_removed(parent);
|
|
|
|
__reqsk_free(req);
|
|
|
|
return child;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int reqsk_queue_removed(struct request_sock_queue *queue,
|
|
|
|
struct request_sock *req)
|
|
|
|
{
|
2005-06-18 23:48:55 -06:00
|
|
|
struct listen_sock *lopt = queue->listen_opt;
|
2005-06-18 23:47:59 -06:00
|
|
|
|
|
|
|
if (req->retrans == 0)
|
|
|
|
--lopt->qlen_young;
|
|
|
|
|
|
|
|
return --lopt->qlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int reqsk_queue_added(struct request_sock_queue *queue)
|
|
|
|
{
|
2005-06-18 23:48:55 -06:00
|
|
|
struct listen_sock *lopt = queue->listen_opt;
|
2005-06-18 23:47:59 -06:00
|
|
|
const int prev_qlen = lopt->qlen;
|
|
|
|
|
|
|
|
lopt->qlen_young++;
|
|
|
|
lopt->qlen++;
|
|
|
|
return prev_qlen;
|
|
|
|
}
|
|
|
|
|
2005-08-09 21:10:42 -06:00
|
|
|
static inline int reqsk_queue_len(const struct request_sock_queue *queue)
|
2005-06-18 23:47:59 -06:00
|
|
|
{
|
|
|
|
return queue->listen_opt != NULL ? queue->listen_opt->qlen : 0;
|
|
|
|
}
|
|
|
|
|
2005-08-09 21:10:42 -06:00
|
|
|
static inline int reqsk_queue_len_young(const struct request_sock_queue *queue)
|
2005-06-18 23:47:59 -06:00
|
|
|
{
|
|
|
|
return queue->listen_opt->qlen_young;
|
|
|
|
}
|
|
|
|
|
2005-08-09 21:10:42 -06:00
|
|
|
static inline int reqsk_queue_is_full(const struct request_sock_queue *queue)
|
2005-06-18 23:47:59 -06:00
|
|
|
{
|
|
|
|
return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void reqsk_queue_hash_req(struct request_sock_queue *queue,
|
|
|
|
u32 hash, struct request_sock *req,
|
2005-12-14 00:15:24 -07:00
|
|
|
unsigned long timeout)
|
2005-06-18 23:47:59 -06:00
|
|
|
{
|
2005-06-18 23:48:55 -06:00
|
|
|
struct listen_sock *lopt = queue->listen_opt;
|
2005-06-18 23:47:59 -06:00
|
|
|
|
|
|
|
req->expires = jiffies + timeout;
|
|
|
|
req->retrans = 0;
|
|
|
|
req->sk = NULL;
|
|
|
|
req->dl_next = lopt->syn_table[hash];
|
|
|
|
|
|
|
|
write_lock(&queue->syn_wait_lock);
|
|
|
|
lopt->syn_table[hash] = req;
|
|
|
|
write_unlock(&queue->syn_wait_lock);
|
|
|
|
}
|
|
|
|
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-18 23:46:52 -06:00
|
|
|
#endif /* _REQUEST_SOCK_H */
|