[linux-block.git] / net / mptcp / mptcp_diag.c

// SPDX-License-Identifier: GPL-2.0
/* MPTCP socket monitoring support
 *
 * Copyright (c) 2020 Red Hat
 *
 * Author: Paolo Abeni <pabeni@redhat.com>
 */

#include <linux/kernel.h>
#include <linux/net.h>
#include <linux/inet_diag.h>
#include <net/netlink.h>
#include <uapi/linux/mptcp.h>
#include "protocol.h"

static int sk_diag_dump(struct sock *sk, struct sk_buff *skb,
			struct netlink_callback *cb,
			const struct inet_diag_req_v2 *req,
			struct nlattr *bc, bool net_admin)
{
	if (!inet_diag_bc_sk(bc, sk))
		return 0;

	return inet_sk_diag_fill(sk, inet_csk(sk), skb, cb, req, NLM_F_MULTI,
				 net_admin);
}

static int mptcp_diag_dump_one(struct netlink_callback *cb,
			       const struct inet_diag_req_v2 *req)
{
	struct sk_buff *in_skb = cb->skb;
	struct mptcp_sock *msk = NULL;
	struct sk_buff *rep;
	int err = -ENOENT;
	struct net *net;
	struct sock *sk;

	net = sock_net(in_skb->sk);
	msk = mptcp_token_get_sock(req->id.idiag_cookie[0]);
	if (!msk)
		goto out_nosk;

	err = -ENOMEM;
	sk = (struct sock *)msk;
	rep = nlmsg_new(nla_total_size(sizeof(struct inet_diag_msg)) +
			inet_diag_msg_attrs_size() +
			nla_total_size(sizeof(struct mptcp_info)) +
			nla_total_size(sizeof(struct inet_diag_meminfo)) + 64,
			GFP_KERNEL);
	if (!rep)
		goto out;

	err = inet_sk_diag_fill(sk, inet_csk(sk), rep, cb, req, 0,
				netlink_net_capable(in_skb, CAP_NET_ADMIN));
	if (err < 0) {
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(rep);
		goto out;
	}
	err = netlink_unicast(net->diag_nlsk, rep, NETLINK_CB(in_skb).portid,
			      MSG_DONTWAIT);
	if (err > 0)
		err = 0;
out:
	sock_put(sk);

out_nosk:
	return err;
}

static void mptcp_diag_dump(struct sk_buff *skb, struct netlink_callback *cb,
			    const struct inet_diag_req_v2 *r)
{
	bool net_admin = netlink_net_capable(cb->skb, CAP_NET_ADMIN);
	struct net *net = sock_net(skb->sk);
	struct inet_diag_dump_data *cb_data;
	struct mptcp_sock *msk;
	struct nlattr *bc;

	cb_data = cb->data;
	bc = cb_data->inet_diag_nla_bc;

	while ((msk = mptcp_token_iter_next(net, &cb->args[0], &cb->args[1])) !=
	       NULL) {
		struct inet_sock *inet = (struct inet_sock *)msk;
		struct sock *sk = (struct sock *)msk;
		int ret = 0;

		if (!(r->idiag_states & (1 << sk->sk_state)))
			goto next;
		if (r->sdiag_family != AF_UNSPEC &&
		    sk->sk_family != r->sdiag_family)
			goto next;
		if (r->id.idiag_sport != inet->inet_sport &&
		    r->id.idiag_sport)
			goto next;
		if (r->id.idiag_dport != inet->inet_dport &&
		    r->id.idiag_dport)
			goto next;

		ret = sk_diag_dump(sk, skb, cb, r, bc, net_admin);
next:
		sock_put(sk);
		if (ret < 0) {
			/* will retry on the same position */
			cb->args[1]--;
			break;
		}
		cond_resched();
	}
}

static void mptcp_diag_get_info(struct sock *sk, struct inet_diag_msg *r,
				void *_info)
{
	struct mptcp_sock *msk = mptcp_sk(sk);
	struct mptcp_info *info = _info;
	u32 flags = 0;
	bool slow;
	u8 val;

	r->idiag_rqueue = sk_rmem_alloc_get(sk);
	r->idiag_wqueue = sk_wmem_alloc_get(sk);
	if (!info)
		return;

	slow = lock_sock_fast(sk);
	info->mptcpi_subflows = READ_ONCE(msk->pm.subflows);
	info->mptcpi_add_addr_signal = READ_ONCE(msk->pm.add_addr_signaled);
	info->mptcpi_add_addr_accepted = READ_ONCE(msk->pm.add_addr_accepted);
	info->mptcpi_local_addr_used = READ_ONCE(msk->pm.local_addr_used);
	info->mptcpi_subflows_max = mptcp_pm_get_subflows_max(msk);
	val = mptcp_pm_get_add_addr_signal_max(msk);
	info->mptcpi_add_addr_signal_max = val;
	val = mptcp_pm_get_add_addr_accept_max(msk);
	info->mptcpi_add_addr_accepted_max = val;
	info->mptcpi_local_addr_max = mptcp_pm_get_local_addr_max(msk);
	if (test_bit(MPTCP_FALLBACK_DONE, &msk->flags))
		flags |= MPTCP_INFO_FLAG_FALLBACK;
	if (READ_ONCE(msk->can_ack))
		flags |= MPTCP_INFO_FLAG_REMOTE_KEY_RECEIVED;
	info->mptcpi_flags = flags;
	info->mptcpi_token = READ_ONCE(msk->token);
	info->mptcpi_write_seq = READ_ONCE(msk->write_seq);
	info->mptcpi_snd_una = READ_ONCE(msk->snd_una);
	info->mptcpi_rcv_nxt = READ_ONCE(msk->ack_seq);
	unlock_sock_fast(sk, slow);
}

static const struct inet_diag_handler mptcp_diag_handler = {
	.dump		 = mptcp_diag_dump,
	.dump_one	 = mptcp_diag_dump_one,
	.idiag_get_info  = mptcp_diag_get_info,
	.idiag_type	 = IPPROTO_MPTCP,
	.idiag_info_size = sizeof(struct mptcp_info),
};

static int __init mptcp_diag_init(void)
{
	return inet_diag_register(&mptcp_diag_handler);
}

static void __exit mptcp_diag_exit(void)
{
	inet_diag_unregister(&mptcp_diag_handler);
}

module_init(mptcp_diag_init);
module_exit(mptcp_diag_exit);
MODULE_LICENSE("GPL");
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-262 /* AF_INET - IPPROTO_MPTCP */);
Commit	Line	Data
ac3b45f6 PA	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
	16	static 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
	28	static 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;
	64	out:
65	sock_put(sk);
66
67	out_nosk:
68	return err;
69	}
70
71	static 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);
102	next:
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
113	static 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);
0caf3ada	131	info->mptcpi_local_addr_used = READ_ONCE(msk->pm.local_addr_used);
a914e586 GT	132	info->mptcpi_subflows_max = mptcp_pm_get_subflows_max(msk);
a914e586 GT	133	val = mptcp_pm_get_add_addr_signal_max(msk);
ac3b45f6	134	info->mptcpi_add_addr_signal_max = val;
a914e586	135	val = mptcp_pm_get_add_addr_accept_max(msk);
ac3b45f6	136	info->mptcpi_add_addr_accepted_max = val;
0caf3ada	137	info->mptcpi_local_addr_max = mptcp_pm_get_local_addr_max(msk);
ac3b45f6 PA	138	if (test_bit(MPTCP_FALLBACK_DONE, &msk->flags))
	139	flags \|= MPTCP_INFO_FLAG_FALLBACK;
	140	if (READ_ONCE(msk->can_ack))
	141	flags \|= MPTCP_INFO_FLAG_REMOTE_KEY_RECEIVED;
	142	info->mptcpi_flags = flags;
	143	info->mptcpi_token = READ_ONCE(msk->token);
	144	info->mptcpi_write_seq = READ_ONCE(msk->write_seq);
7439d687	145	info->mptcpi_snd_una = READ_ONCE(msk->snd_una);
ac3b45f6 PA	146	info->mptcpi_rcv_nxt = READ_ONCE(msk->ack_seq);
	147	unlock_sock_fast(sk, slow);
	148	}
	149
	150	static const struct inet_diag_handler mptcp_diag_handler = {
	151	.dump = mptcp_diag_dump,
	152	.dump_one = mptcp_diag_dump_one,
	153	.idiag_get_info = mptcp_diag_get_info,
	154	.idiag_type = IPPROTO_MPTCP,
	155	.idiag_info_size = sizeof(struct mptcp_info),
	156	};
	157
	158	static int __init mptcp_diag_init(void)
	159	{
	160	return inet_diag_register(&mptcp_diag_handler);
	161	}
	162
	163	static void __exit mptcp_diag_exit(void)
	164	{
	165	inet_diag_unregister(&mptcp_diag_handler);
	166	}
	167
	168	module_init(mptcp_diag_init);
	169	module_exit(mptcp_diag_exit);
	170	MODULE_LICENSE("GPL");
	171	MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, 2-262 /* AF_INET - IPPROTO_MPTCP */);