[mirror_ubuntu-bionic-kernel.git] / net / vmw_vsock / diag.c

/*
 * vsock sock_diag(7) module
 *
 * Copyright (C) 2017 Red Hat, Inc.
 * Author: Stefan Hajnoczi <stefanha@redhat.com>
 *
 * 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 version 2 and no later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 */

#include <linux/module.h>
#include <linux/sock_diag.h>
#include <linux/vm_sockets_diag.h>
#include <net/af_vsock.h>

static int sk_diag_fill(struct sock *sk, struct sk_buff *skb,
			u32 portid, u32 seq, u32 flags)
{
	struct vsock_sock *vsk = vsock_sk(sk);
	struct vsock_diag_msg *rep;
	struct nlmsghdr *nlh;

	nlh = nlmsg_put(skb, portid, seq, SOCK_DIAG_BY_FAMILY, sizeof(*rep),
			flags);
	if (!nlh)
		return -EMSGSIZE;

	rep = nlmsg_data(nlh);
	rep->vdiag_family = AF_VSOCK;

	/* Lock order dictates that sk_lock is acquired before
	 * vsock_table_lock, so we cannot lock here.  Simply don't take
	 * sk_lock; sk is guaranteed to stay alive since vsock_table_lock is
	 * held.
	 */
	rep->vdiag_type = sk->sk_type;
	rep->vdiag_state = sk->sk_state;
	rep->vdiag_shutdown = sk->sk_shutdown;
	rep->vdiag_src_cid = vsk->local_addr.svm_cid;
	rep->vdiag_src_port = vsk->local_addr.svm_port;
	rep->vdiag_dst_cid = vsk->remote_addr.svm_cid;
	rep->vdiag_dst_port = vsk->remote_addr.svm_port;
	rep->vdiag_ino = sock_i_ino(sk);

	sock_diag_save_cookie(sk, rep->vdiag_cookie);

	return 0;
}

static int vsock_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct vsock_diag_req *req;
	struct vsock_sock *vsk;
	unsigned int bucket;
	unsigned int last_i;
	unsigned int table;
	struct net *net;
	unsigned int i;

	req = nlmsg_data(cb->nlh);
	net = sock_net(skb->sk);

	/* State saved between calls: */
	table = cb->args[0];
	bucket = cb->args[1];
	i = last_i = cb->args[2];

	/* TODO VMCI pending sockets? */

	spin_lock_bh(&vsock_table_lock);

	/* Bind table (locally created sockets) */
	if (table == 0) {
		while (bucket < ARRAY_SIZE(vsock_bind_table)) {
			struct list_head *head = &vsock_bind_table[bucket];

			i = 0;
			list_for_each_entry(vsk, head, bound_table) {
				struct sock *sk = sk_vsock(vsk);

				if (!net_eq(sock_net(sk), net))
					continue;
				if (i < last_i)
					goto next_bind;
				if (!(req->vdiag_states & (1 << sk->sk_state)))
					goto next_bind;
				if (sk_diag_fill(sk, skb,
						 NETLINK_CB(cb->skb).portid,
						 cb->nlh->nlmsg_seq,
						 NLM_F_MULTI) < 0)
					goto done;
next_bind:
				i++;
			}
			last_i = 0;
			bucket++;
		}

		table++;
		bucket = 0;
	}

	/* Connected table (accepted connections) */
	while (bucket < ARRAY_SIZE(vsock_connected_table)) {
		struct list_head *head = &vsock_connected_table[bucket];

		i = 0;
		list_for_each_entry(vsk, head, connected_table) {
			struct sock *sk = sk_vsock(vsk);

			/* Skip sockets we've already seen above */
			if (__vsock_in_bound_table(vsk))
				continue;

			if (!net_eq(sock_net(sk), net))
				continue;
			if (i < last_i)
				goto next_connected;
			if (!(req->vdiag_states & (1 << sk->sk_state)))
				goto next_connected;
			if (sk_diag_fill(sk, skb,
					 NETLINK_CB(cb->skb).portid,
					 cb->nlh->nlmsg_seq,
					 NLM_F_MULTI) < 0)
				goto done;
next_connected:
			i++;
		}
		last_i = 0;
		bucket++;
	}

done:
	spin_unlock_bh(&vsock_table_lock);

	cb->args[0] = table;
	cb->args[1] = bucket;
	cb->args[2] = i;

	return skb->len;
}

static int vsock_diag_handler_dump(struct sk_buff *skb, struct nlmsghdr *h)
{
	int hdrlen = sizeof(struct vsock_diag_req);
	struct net *net = sock_net(skb->sk);

	if (nlmsg_len(h) < hdrlen)
		return -EINVAL;

	if (h->nlmsg_flags & NLM_F_DUMP) {
		struct netlink_dump_control c = {
			.dump = vsock_diag_dump,
		};
		return netlink_dump_start(net->diag_nlsk, skb, h, &c);
	}

	return -EOPNOTSUPP;
}

static const struct sock_diag_handler vsock_diag_handler = {
	.family = AF_VSOCK,
	.dump = vsock_diag_handler_dump,
};

static int __init vsock_diag_init(void)
{
	return sock_diag_register(&vsock_diag_handler);
}

static void __exit vsock_diag_exit(void)
{
	sock_diag_unregister(&vsock_diag_handler);
}

module_init(vsock_diag_init);
module_exit(vsock_diag_exit);
MODULE_LICENSE("GPL");
MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG,
			       40 /* AF_VSOCK */);
Commit	Line	Data
413a4317 SH	1	/*
	2	* vsock sock_diag(7) module
	3	*
	4	* Copyright (C) 2017 Red Hat, Inc.
	5	* Author: Stefan Hajnoczi <stefanha@redhat.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the Free
	9	* Software Foundation version 2 and no later version.
	10	*
	11	* This program is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	14	* more details.
	15	*/
	16
	17	#include <linux/module.h>
	18	#include <linux/sock_diag.h>
	19	#include <linux/vm_sockets_diag.h>
	20	#include <net/af_vsock.h>
	21
	22	static int sk_diag_fill(struct sock sk, struct sk_buff skb,
	23	u32 portid, u32 seq, u32 flags)
	24	{
	25	struct vsock_sock *vsk = vsock_sk(sk);
	26	struct vsock_diag_msg *rep;
	27	struct nlmsghdr *nlh;
	28
	29	nlh = nlmsg_put(skb, portid, seq, SOCK_DIAG_BY_FAMILY, sizeof(*rep),
	30	flags);
	31	if (!nlh)
	32	return -EMSGSIZE;
	33
	34	rep = nlmsg_data(nlh);
	35	rep->vdiag_family = AF_VSOCK;
	36
	37	/* Lock order dictates that sk_lock is acquired before
	38	* vsock_table_lock, so we cannot lock here. Simply don't take
	39	* sk_lock; sk is guaranteed to stay alive since vsock_table_lock is
	40	* held.
	41	*/
	42	rep->vdiag_type = sk->sk_type;
	43	rep->vdiag_state = sk->sk_state;
	44	rep->vdiag_shutdown = sk->sk_shutdown;
	45	rep->vdiag_src_cid = vsk->local_addr.svm_cid;
	46	rep->vdiag_src_port = vsk->local_addr.svm_port;
	47	rep->vdiag_dst_cid = vsk->remote_addr.svm_cid;
	48	rep->vdiag_dst_port = vsk->remote_addr.svm_port;
	49	rep->vdiag_ino = sock_i_ino(sk);
	50
	51	sock_diag_save_cookie(sk, rep->vdiag_cookie);
	52
	53	return 0;
	54	}
	55
	56	static int vsock_diag_dump(struct sk_buff skb, struct netlink_callback cb)
	57	{
	58	struct vsock_diag_req *req;
	59	struct vsock_sock *vsk;
	60	unsigned int bucket;
	61	unsigned int last_i;
	62	unsigned int table;
	63	struct net *net;
	64	unsigned int i;
65
66	req = nlmsg_data(cb->nlh);
67	net = sock_net(skb->sk);
68
69	/* State saved between calls: */
70	table = cb->args[0];
71	bucket = cb->args[1];
72	i = last_i = cb->args[2];
73
74	/* TODO VMCI pending sockets? */
75
76	spin_lock_bh(&vsock_table_lock);
77
78	/* Bind table (locally created sockets) */
79	if (table == 0) {
80	while (bucket < ARRAY_SIZE(vsock_bind_table)) {
81	struct list_head *head = &vsock_bind_table[bucket];
82
83	i = 0;
84	list_for_each_entry(vsk, head, bound_table) {
85	struct sock *sk = sk_vsock(vsk);
86
87	if (!net_eq(sock_net(sk), net))
88	continue;
89	if (i < last_i)
90	goto next_bind;
91	if (!(req->vdiag_states & (1 << sk->sk_state)))
92	goto next_bind;
93	if (sk_diag_fill(sk, skb,
94	NETLINK_CB(cb->skb).portid,
95	cb->nlh->nlmsg_seq,
96	NLM_F_MULTI) < 0)
97	goto done;
98	next_bind:
99	i++;
100	}
101	last_i = 0;
102	bucket++;
103	}
104
105	table++;
106	bucket = 0;
107	}
108
109	/* Connected table (accepted connections) */
110	while (bucket < ARRAY_SIZE(vsock_connected_table)) {
111	struct list_head *head = &vsock_connected_table[bucket];
112
113	i = 0;
114	list_for_each_entry(vsk, head, connected_table) {
115	struct sock *sk = sk_vsock(vsk);
116
117	/* Skip sockets we've already seen above */
118	if (__vsock_in_bound_table(vsk))
119	continue;
120
121	if (!net_eq(sock_net(sk), net))
122	continue;
123	if (i < last_i)
124	goto next_connected;
125	if (!(req->vdiag_states & (1 << sk->sk_state)))
126	goto next_connected;
127	if (sk_diag_fill(sk, skb,
128	NETLINK_CB(cb->skb).portid,
129	cb->nlh->nlmsg_seq,
130	NLM_F_MULTI) < 0)
131	goto done;
132	next_connected:
133	i++;
134	}
135	last_i = 0;
136	bucket++;
137	}
138
139	done:
140	spin_unlock_bh(&vsock_table_lock);
141
142	cb->args[0] = table;
143	cb->args[1] = bucket;
144	cb->args[2] = i;
145
146	return skb->len;
147	}
148
149	static int vsock_diag_handler_dump(struct sk_buff skb, struct nlmsghdr h)
150	{
151	int hdrlen = sizeof(struct vsock_diag_req);
152	struct net *net = sock_net(skb->sk);
153
154	if (nlmsg_len(h) < hdrlen)
155	return -EINVAL;
156
157	if (h->nlmsg_flags & NLM_F_DUMP) {
158	struct netlink_dump_control c = {
159	.dump = vsock_diag_dump,
160	};
161	return netlink_dump_start(net->diag_nlsk, skb, h, &c);
162	}
163
164	return -EOPNOTSUPP;
165	}
166
167	static const struct sock_diag_handler vsock_diag_handler = {
168	.family = AF_VSOCK,
169	.dump = vsock_diag_handler_dump,
170	};
171
172	static int __init vsock_diag_init(void)
173	{
174	return sock_diag_register(&vsock_diag_handler);
175	}
176
177	static void __exit vsock_diag_exit(void)
178	{
179	sock_diag_unregister(&vsock_diag_handler);
180	}
181
182	module_init(vsock_diag_init);
183	module_exit(vsock_diag_exit);
184	MODULE_LICENSE("GPL");
185	MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG,
186	40 /* AF_VSOCK */);