Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'tcp-small-code-reorg'
Eric Dumazet says:
====================
tcp: small code reorg
Replace a WARN_ON_ONCE() that never triggered
to DEBUG_NET_WARN_ON_ONCE() in reqsk_free().
Move inet_reqsk_alloc() and reqsk_alloc()
to inet_connection_sock.c, to unclutter
net/ipv4/tcp_input.c and include/net/request_sock.h
====================
Link: https://lore.kernel.org/r/20240605071553.1365557-1-edumazet@google.com
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
+60
-60
+2
-35
include/net/request_sock.h
+2
-35
include/net/request_sock.h
···
128
128
return sk;
129
129
}
130
130
131
-
static inline struct request_sock *
132
-
reqsk_alloc_noprof(const struct request_sock_ops *ops, struct sock *sk_listener,
133
-
bool attach_listener)
134
-
{
135
-
struct request_sock *req;
136
-
137
-
req = kmem_cache_alloc_noprof(ops->slab, GFP_ATOMIC | __GFP_NOWARN);
138
-
if (!req)
139
-
return NULL;
140
-
req->rsk_listener = NULL;
141
-
if (attach_listener) {
142
-
if (unlikely(!refcount_inc_not_zero(&sk_listener->sk_refcnt))) {
143
-
kmem_cache_free(ops->slab, req);
144
-
return NULL;
145
-
}
146
-
req->rsk_listener = sk_listener;
147
-
}
148
-
req->rsk_ops = ops;
149
-
req_to_sk(req)->sk_prot = sk_listener->sk_prot;
150
-
sk_node_init(&req_to_sk(req)->sk_node);
151
-
sk_tx_queue_clear(req_to_sk(req));
152
-
req->saved_syn = NULL;
153
-
req->syncookie = 0;
154
-
req->timeout = 0;
155
-
req->num_timeout = 0;
156
-
req->num_retrans = 0;
157
-
req->sk = NULL;
158
-
refcount_set(&req->rsk_refcnt, 0);
159
-
160
-
return req;
161
-
}
162
-
#define reqsk_alloc(...) alloc_hooks(reqsk_alloc_noprof(__VA_ARGS__))
163
-
164
131
static inline void __reqsk_free(struct request_sock *req)
165
132
{
166
133
req->rsk_ops->destructor(req);
···
139
172
140
173
static inline void reqsk_free(struct request_sock *req)
141
174
{
142
-
WARN_ON_ONCE(refcount_read(&req->rsk_refcnt) != 0);
175
+
DEBUG_NET_WARN_ON_ONCE(refcount_read(&req->rsk_refcnt) != 0);
143
176
__reqsk_free(req);
144
177
}
145
178
146
179
static inline void reqsk_put(struct request_sock *req)
147
180
{
148
181
if (refcount_dec_and_test(&req->rsk_refcnt))
149
-
reqsk_free(req);
182
+
__reqsk_free(req);
150
183
}
151
184
152
185
/*
+58
net/ipv4/inet_connection_sock.c
+58
net/ipv4/inet_connection_sock.c
···
911
911
}
912
912
EXPORT_SYMBOL(inet_rtx_syn_ack);
913
913
914
+
static struct request_sock *
915
+
reqsk_alloc_noprof(const struct request_sock_ops *ops, struct sock *sk_listener,
916
+
bool attach_listener)
917
+
{
918
+
struct request_sock *req;
919
+
920
+
req = kmem_cache_alloc_noprof(ops->slab, GFP_ATOMIC | __GFP_NOWARN);
921
+
if (!req)
922
+
return NULL;
923
+
req->rsk_listener = NULL;
924
+
if (attach_listener) {
925
+
if (unlikely(!refcount_inc_not_zero(&sk_listener->sk_refcnt))) {
926
+
kmem_cache_free(ops->slab, req);
927
+
return NULL;
928
+
}
929
+
req->rsk_listener = sk_listener;
930
+
}
931
+
req->rsk_ops = ops;
932
+
req_to_sk(req)->sk_prot = sk_listener->sk_prot;
933
+
sk_node_init(&req_to_sk(req)->sk_node);
934
+
sk_tx_queue_clear(req_to_sk(req));
935
+
req->saved_syn = NULL;
936
+
req->syncookie = 0;
937
+
req->timeout = 0;
938
+
req->num_timeout = 0;
939
+
req->num_retrans = 0;
940
+
req->sk = NULL;
941
+
refcount_set(&req->rsk_refcnt, 0);
942
+
943
+
return req;
944
+
}
945
+
#define reqsk_alloc(...) alloc_hooks(reqsk_alloc_noprof(__VA_ARGS__))
946
+
947
+
struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
948
+
struct sock *sk_listener,
949
+
bool attach_listener)
950
+
{
951
+
struct request_sock *req = reqsk_alloc(ops, sk_listener,
952
+
attach_listener);
953
+
954
+
if (req) {
955
+
struct inet_request_sock *ireq = inet_rsk(req);
956
+
957
+
ireq->ireq_opt = NULL;
958
+
#if IS_ENABLED(CONFIG_IPV6)
959
+
ireq->pktopts = NULL;
960
+
#endif
961
+
atomic64_set(&ireq->ir_cookie, 0);
962
+
ireq->ireq_state = TCP_NEW_SYN_RECV;
963
+
write_pnet(&ireq->ireq_net, sock_net(sk_listener));
964
+
ireq->ireq_family = sk_listener->sk_family;
965
+
req->timeout = TCP_TIMEOUT_INIT;
966
+
}
967
+
968
+
return req;
969
+
}
970
+
EXPORT_SYMBOL(inet_reqsk_alloc);
971
+
914
972
static struct request_sock *inet_reqsk_clone(struct request_sock *req,
915
973
struct sock *sk)
916
974
{
-25
net/ipv4/tcp_input.c
-25
net/ipv4/tcp_input.c
···
6986
6986
#endif
6987
6987
}
6988
6988
6989
-
struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
6990
-
struct sock *sk_listener,
6991
-
bool attach_listener)
6992
-
{
6993
-
struct request_sock *req = reqsk_alloc(ops, sk_listener,
6994
-
attach_listener);
6995
-
6996
-
if (req) {
6997
-
struct inet_request_sock *ireq = inet_rsk(req);
6998
-
6999
-
ireq->ireq_opt = NULL;
7000
-
#if IS_ENABLED(CONFIG_IPV6)
7001
-
ireq->pktopts = NULL;
7002
-
#endif
7003
-
atomic64_set(&ireq->ir_cookie, 0);
7004
-
ireq->ireq_state = TCP_NEW_SYN_RECV;
7005
-
write_pnet(&ireq->ireq_net, sock_net(sk_listener));
7006
-
ireq->ireq_family = sk_listener->sk_family;
7007
-
req->timeout = TCP_TIMEOUT_INIT;
7008
-
}
7009
-
7010
-
return req;
7011
-
}
7012
-
EXPORT_SYMBOL(inet_reqsk_alloc);
7013
-
7014
6989
/*
7015
6990
* Return true if a syncookie should be sent
7016
6991
*/