Loading...
1// SPDX-License-Identifier: GPL-2.0
2/* MPTCP socket monitoring support
3 *
4 * Copyright (c) 2020 Red Hat
5 *
6 * Author: Paolo Abeni <pabeni@redhat.com>
7 */
8
9#include <linux/kernel.h>
10#include <linux/net.h>
11#include <linux/inet_diag.h>
12#include <net/netlink.h>
13#include "protocol.h"
14
15static int sk_diag_dump(struct sock *sk, struct sk_buff *skb,
16 struct netlink_callback *cb,
17 const struct inet_diag_req_v2 *req,
18 struct nlattr *bc, bool net_admin)
19{
20 if (!inet_diag_bc_sk(bc, sk))
21 return 0;
22
23 return inet_sk_diag_fill(sk, inet_csk(sk), skb, cb, req, NLM_F_MULTI,
24 net_admin);
25}
26
27static int mptcp_diag_dump_one(struct netlink_callback *cb,
28 const struct inet_diag_req_v2 *req)
29{
30 struct sk_buff *in_skb = cb->skb;
31 struct mptcp_sock *msk = NULL;
32 struct sk_buff *rep;
33 int err = -ENOENT;
34 struct net *net;
35 struct sock *sk;
36
37 net = sock_net(in_skb->sk);
38 msk = mptcp_token_get_sock(net, req->id.idiag_cookie[0]);
39 if (!msk)
40 goto out_nosk;
41
42 err = -ENOMEM;
43 sk = (struct sock *)msk;
44 rep = nlmsg_new(nla_total_size(sizeof(struct inet_diag_msg)) +
45 inet_diag_msg_attrs_size() +
46 nla_total_size(sizeof(struct mptcp_info)) +
47 nla_total_size(sizeof(struct inet_diag_meminfo)) + 64,
48 GFP_KERNEL);
49 if (!rep)
50 goto out;
51
52 err = inet_sk_diag_fill(sk, inet_csk(sk), rep, cb, req, 0,
53 netlink_net_capable(in_skb, CAP_NET_ADMIN));
54 if (err < 0) {
55 WARN_ON(err == -EMSGSIZE);
56 kfree_skb(rep);
57 goto out;
58 }
59 err = nlmsg_unicast(net->diag_nlsk, rep, NETLINK_CB(in_skb).portid);
60
61out:
62 sock_put(sk);
63
64out_nosk:
65 return err;
66}
67
68struct mptcp_diag_ctx {
69 long s_slot;
70 long s_num;
71 unsigned int l_slot;
72 unsigned int l_num;
73};
74
75static void mptcp_diag_dump_listeners(struct sk_buff *skb, struct netlink_callback *cb,
76 const struct inet_diag_req_v2 *r,
77 bool net_admin)
78{
79 struct inet_diag_dump_data *cb_data = cb->data;
80 struct mptcp_diag_ctx *diag_ctx = (void *)cb->ctx;
81 struct nlattr *bc = cb_data->inet_diag_nla_bc;
82 struct net *net = sock_net(skb->sk);
83 struct inet_hashinfo *hinfo;
84 int i;
85
86 hinfo = net->ipv4.tcp_death_row.hashinfo;
87
88 for (i = diag_ctx->l_slot; i <= hinfo->lhash2_mask; i++) {
89 struct inet_listen_hashbucket *ilb;
90 struct hlist_nulls_node *node;
91 struct sock *sk;
92 int num = 0;
93
94 ilb = &hinfo->lhash2[i];
95
96 rcu_read_lock();
97 spin_lock(&ilb->lock);
98 sk_nulls_for_each(sk, node, &ilb->nulls_head) {
99 const struct mptcp_subflow_context *ctx = mptcp_subflow_ctx(sk);
100 struct inet_sock *inet = inet_sk(sk);
101 int ret;
102
103 if (num < diag_ctx->l_num)
104 goto next_listen;
105
106 if (!ctx || strcmp(inet_csk(sk)->icsk_ulp_ops->name, "mptcp"))
107 goto next_listen;
108
109 sk = ctx->conn;
110 if (!sk || !net_eq(sock_net(sk), net))
111 goto next_listen;
112
113 if (r->sdiag_family != AF_UNSPEC &&
114 sk->sk_family != r->sdiag_family)
115 goto next_listen;
116
117 if (r->id.idiag_sport != inet->inet_sport &&
118 r->id.idiag_sport)
119 goto next_listen;
120
121 if (!refcount_inc_not_zero(&sk->sk_refcnt))
122 goto next_listen;
123
124 ret = sk_diag_dump(sk, skb, cb, r, bc, net_admin);
125
126 sock_put(sk);
127
128 if (ret < 0) {
129 spin_unlock(&ilb->lock);
130 rcu_read_unlock();
131 diag_ctx->l_slot = i;
132 diag_ctx->l_num = num;
133 return;
134 }
135 diag_ctx->l_num = num + 1;
136 num = 0;
137next_listen:
138 ++num;
139 }
140 spin_unlock(&ilb->lock);
141 rcu_read_unlock();
142
143 cond_resched();
144 diag_ctx->l_num = 0;
145 }
146
147 diag_ctx->l_num = 0;
148 diag_ctx->l_slot = i;
149}
150
151static void mptcp_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
152 const struct inet_diag_req_v2 *r)
153{
154 bool net_admin = netlink_net_capable(cb->skb, CAP_NET_ADMIN);
155 struct mptcp_diag_ctx *diag_ctx = (void *)cb->ctx;
156 struct net *net = sock_net(skb->sk);
157 struct inet_diag_dump_data *cb_data;
158 struct mptcp_sock *msk;
159 struct nlattr *bc;
160
161 BUILD_BUG_ON(sizeof(cb->ctx) < sizeof(*diag_ctx));
162
163 cb_data = cb->data;
164 bc = cb_data->inet_diag_nla_bc;
165
166 while ((msk = mptcp_token_iter_next(net, &diag_ctx->s_slot,
167 &diag_ctx->s_num)) != NULL) {
168 struct inet_sock *inet = (struct inet_sock *)msk;
169 struct sock *sk = (struct sock *)msk;
170 int ret = 0;
171
172 if (!(r->idiag_states & (1 << sk->sk_state)))
173 goto next;
174 if (r->sdiag_family != AF_UNSPEC &&
175 sk->sk_family != r->sdiag_family)
176 goto next;
177 if (r->id.idiag_sport != inet->inet_sport &&
178 r->id.idiag_sport)
179 goto next;
180 if (r->id.idiag_dport != inet->inet_dport &&
181 r->id.idiag_dport)
182 goto next;
183
184 ret = sk_diag_dump(sk, skb, cb, r, bc, net_admin);
185next:
186 sock_put(sk);
187 if (ret < 0) {
188 /* will retry on the same position */
189 diag_ctx->s_num--;
190 break;
191 }
192 cond_resched();
193 }
194
195 if ((r->idiag_states & TCPF_LISTEN) && r->id.idiag_dport == 0)
196 mptcp_diag_dump_listeners(skb, cb, r, net_admin);
197}
198
199static void mptcp_diag_get_info(struct sock *sk, struct inet_diag_msg *r,
200 void *_info)
201{
202 struct mptcp_sock *msk = mptcp_sk(sk);
203 struct mptcp_info *info = _info;
204
205 r->idiag_rqueue = sk_rmem_alloc_get(sk);
206 r->idiag_wqueue = sk_wmem_alloc_get(sk);
207
208 if (inet_sk_state_load(sk) == TCP_LISTEN) {
209 struct sock *lsk = READ_ONCE(msk->first);
210
211 if (lsk) {
212 /* override with settings from tcp listener,
213 * so Send-Q will show accept queue.
214 */
215 r->idiag_rqueue = READ_ONCE(lsk->sk_ack_backlog);
216 r->idiag_wqueue = READ_ONCE(lsk->sk_max_ack_backlog);
217 }
218 }
219
220 if (!info)
221 return;
222
223 mptcp_diag_fill_info(msk, info);
224}
225
226static const struct inet_diag_handler mptcp_diag_handler = {
227 .owner = THIS_MODULE,
228 .dump = mptcp_diag_dump,
229 .dump_one = mptcp_diag_dump_one,
230 .idiag_get_info = mptcp_diag_get_info,
231 .idiag_type = IPPROTO_MPTCP,
232 .idiag_info_size = sizeof(struct mptcp_info),
233};
234
235static int __init mptcp_diag_init(void)
236{
237 return inet_diag_register(&mptcp_diag_handler);
238}
239
240static void __exit mptcp_diag_exit(void)
241{
242 inet_diag_unregister(&mptcp_diag_handler);
243}
244
245module_init(mptcp_diag_init);
246module_exit(mptcp_diag_exit);
247MODULE_LICENSE("GPL");
248MODULE_DESCRIPTION("MPTCP socket monitoring via SOCK_DIAG");
249MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-262 /* AF_INET - IPPROTO_MPTCP */);
1// SPDX-License-Identifier: GPL-2.0
2/* MPTCP socket monitoring support
3 *
4 * Copyright (c) 2020 Red Hat
5 *
6 * Author: Paolo Abeni <pabeni@redhat.com>
7 */
8
9#include <linux/kernel.h>
10#include <linux/net.h>
11#include <linux/inet_diag.h>
12#include <net/netlink.h>
13#include <uapi/linux/mptcp.h>
14#include "protocol.h"
15
16static int sk_diag_dump(struct sock *sk, struct sk_buff *skb,
17 struct netlink_callback *cb,
18 const struct inet_diag_req_v2 *req,
19 struct nlattr *bc, bool net_admin)
20{
21 if (!inet_diag_bc_sk(bc, sk))
22 return 0;
23
24 return inet_sk_diag_fill(sk, inet_csk(sk), skb, cb, req, NLM_F_MULTI,
25 net_admin);
26}
27
28static int mptcp_diag_dump_one(struct netlink_callback *cb,
29 const struct inet_diag_req_v2 *req)
30{
31 struct sk_buff *in_skb = cb->skb;
32 struct mptcp_sock *msk = NULL;
33 struct sk_buff *rep;
34 int err = -ENOENT;
35 struct net *net;
36 struct sock *sk;
37
38 net = sock_net(in_skb->sk);
39 msk = mptcp_token_get_sock(req->id.idiag_cookie[0]);
40 if (!msk)
41 goto out_nosk;
42
43 err = -ENOMEM;
44 sk = (struct sock *)msk;
45 rep = nlmsg_new(nla_total_size(sizeof(struct inet_diag_msg)) +
46 inet_diag_msg_attrs_size() +
47 nla_total_size(sizeof(struct mptcp_info)) +
48 nla_total_size(sizeof(struct inet_diag_meminfo)) + 64,
49 GFP_KERNEL);
50 if (!rep)
51 goto out;
52
53 err = inet_sk_diag_fill(sk, inet_csk(sk), rep, cb, req, 0,
54 netlink_net_capable(in_skb, CAP_NET_ADMIN));
55 if (err < 0) {
56 WARN_ON(err == -EMSGSIZE);
57 kfree_skb(rep);
58 goto out;
59 }
60 err = netlink_unicast(net->diag_nlsk, rep, NETLINK_CB(in_skb).portid,
61 MSG_DONTWAIT);
62 if (err > 0)
63 err = 0;
64out:
65 sock_put(sk);
66
67out_nosk:
68 return err;
69}
70
71static void mptcp_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
72 const struct inet_diag_req_v2 *r)
73{
74 bool net_admin = netlink_net_capable(cb->skb, CAP_NET_ADMIN);
75 struct net *net = sock_net(skb->sk);
76 struct inet_diag_dump_data *cb_data;
77 struct mptcp_sock *msk;
78 struct nlattr *bc;
79
80 cb_data = cb->data;
81 bc = cb_data->inet_diag_nla_bc;
82
83 while ((msk = mptcp_token_iter_next(net, &cb->args[0], &cb->args[1])) !=
84 NULL) {
85 struct inet_sock *inet = (struct inet_sock *)msk;
86 struct sock *sk = (struct sock *)msk;
87 int ret = 0;
88
89 if (!(r->idiag_states & (1 << sk->sk_state)))
90 goto next;
91 if (r->sdiag_family != AF_UNSPEC &&
92 sk->sk_family != r->sdiag_family)
93 goto next;
94 if (r->id.idiag_sport != inet->inet_sport &&
95 r->id.idiag_sport)
96 goto next;
97 if (r->id.idiag_dport != inet->inet_dport &&
98 r->id.idiag_dport)
99 goto next;
100
101 ret = sk_diag_dump(sk, skb, cb, r, bc, net_admin);
102next:
103 sock_put(sk);
104 if (ret < 0) {
105 /* will retry on the same position */
106 cb->args[1]--;
107 break;
108 }
109 cond_resched();
110 }
111}
112
113static void mptcp_diag_get_info(struct sock *sk, struct inet_diag_msg *r,
114 void *_info)
115{
116 struct mptcp_sock *msk = mptcp_sk(sk);
117 struct mptcp_info *info = _info;
118 u32 flags = 0;
119 bool slow;
120 u8 val;
121
122 r->idiag_rqueue = sk_rmem_alloc_get(sk);
123 r->idiag_wqueue = sk_wmem_alloc_get(sk);
124 if (!info)
125 return;
126
127 slow = lock_sock_fast(sk);
128 info->mptcpi_subflows = READ_ONCE(msk->pm.subflows);
129 info->mptcpi_add_addr_signal = READ_ONCE(msk->pm.add_addr_signaled);
130 info->mptcpi_add_addr_accepted = READ_ONCE(msk->pm.add_addr_accepted);
131 info->mptcpi_subflows_max = READ_ONCE(msk->pm.subflows_max);
132 val = READ_ONCE(msk->pm.add_addr_signal_max);
133 info->mptcpi_add_addr_signal_max = val;
134 val = READ_ONCE(msk->pm.add_addr_accept_max);
135 info->mptcpi_add_addr_accepted_max = val;
136 if (test_bit(MPTCP_FALLBACK_DONE, &msk->flags))
137 flags |= MPTCP_INFO_FLAG_FALLBACK;
138 if (READ_ONCE(msk->can_ack))
139 flags |= MPTCP_INFO_FLAG_REMOTE_KEY_RECEIVED;
140 info->mptcpi_flags = flags;
141 info->mptcpi_token = READ_ONCE(msk->token);
142 info->mptcpi_write_seq = READ_ONCE(msk->write_seq);
143 info->mptcpi_snd_una = atomic64_read(&msk->snd_una);
144 info->mptcpi_rcv_nxt = READ_ONCE(msk->ack_seq);
145 unlock_sock_fast(sk, slow);
146}
147
148static const struct inet_diag_handler mptcp_diag_handler = {
149 .dump = mptcp_diag_dump,
150 .dump_one = mptcp_diag_dump_one,
151 .idiag_get_info = mptcp_diag_get_info,
152 .idiag_type = IPPROTO_MPTCP,
153 .idiag_info_size = sizeof(struct mptcp_info),
154};
155
156static int __init mptcp_diag_init(void)
157{
158 return inet_diag_register(&mptcp_diag_handler);
159}
160
161static void __exit mptcp_diag_exit(void)
162{
163 inet_diag_unregister(&mptcp_diag_handler);
164}
165
166module_init(mptcp_diag_init);
167module_exit(mptcp_diag_exit);
168MODULE_LICENSE("GPL");
169MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-262 /* AF_INET - IPPROTO_MPTCP */);