Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 15769ff8 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'VSOCK-add-vsockmon' 

Stefan Hajnoczi says:

====================
VSOCK: vsockmon virtual device to monitor AF_VSOCK sockets.

v5:
 * Change vsock_deliver_tap() API to avoid unnecessary skb creation
   [Jorgen]
 * Fix skb leak when no taps are registered [Jorgen]
 * s/cpu_to_le16(pkt->hdr.op)/le16_to_cpu(pkt->hdr.op)/ [Michael]
 * Add af_vsock_tap.c and vsockmon.[ch] to MAINTAINERS
 * checkpatch.pl and sparse fixes

v4:
 * Add explicit reserved padding field to struct af_vsockmon_hdr and
   drop __attribute__((packed)) [Michael, DaveM]
 * Call synchronize_net() before module_put() [Michael]

v3:
 * Hook virtio_transport.c (guest driver), not just drivers/vhost/vsock.c (host
   driver)
 * Fix DEFAULT_MTU macro definition [Zhu Yanjun]
 * Rename af_vsockmon_hdr->t field ->transport for clarity
 * Update .ndo_get_stats64() return type since it has changed
 * Include missing <linux/module.h> header in af_vsock_tap.c

This is a continuation of Gerard Garcia's work on the vsockmon packet capture
interface for AF_VSOCK.  Packet capture is an essential feature for network
communication.  Gerard began addressing this feature gap in his Google Summer
of Code 2016 project.  I have cleaned up, rebased, and retested the v2 series
he posted previously.

The design follows the nlmon packet capture interface closely.  This is because
vsock has the same problem as netlink: there is no netdev on which packets can
be captured.  The nlmon driver is a synthetic netdev purely for the purpose of
enabling packet capture.  We follow the same approach here with vsockmon.

See include/uapi/linux/vsockmon.h in this series for details on the packet
layout.

How to try it:

1. Build tcpdump with vsockmon patches:

  $ git clone -b vsock https://github.com/stefanha/libpcap
  $ (cd libcap && ./configure && make)
  $ git clone -b vsock https://github.com/stefanha/tcpdump
  $ (cd tcpdump && ./configure && make)

2. Build nc-vsock (a netcat-like tool):

  $ git clone https://github.com/stefanha/nc-vsock


  $ (cd nc-vsock && make)

3. Launch a virtual machine:

  # modprobe vhost_vsock
  # qemu-system-x86_64 -M accel=kvm -m 1024 -cpu host \
      -drive if=virtio,file=test.img,format=raw \
      -device vhost-vsock-pci,guest-cid=3

  (Assumes guest is running a kernel with this patch)

4. Capture AF_VSOCK traffic in guest and/or host:

  # modprobe vsockmon
  # ip link add type vsockmon
  # ip link set vsockmon0 up
  # tcpdump -i vsockmon0 -vvv

5. Communicate!

  (host)$ nc-vsock -l 1234
  (guest)$ nc-vsock 2 1234
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents ac2291ce 82dfb540

MAINTAINERS

+3 −0
Original line number Diff line number Diff line
@@ -13317,8 +13317,11 @@ L: netdev@vger.kernel.org 
S:	Maintained

F:	include/linux/virtio_vsock.h

F:	include/uapi/linux/virtio_vsock.h

F:	include/uapi/linux/vsockmon.h

F:	net/vmw_vsock/af_vsock_tap.c

F:	net/vmw_vsock/virtio_transport_common.c

F:	net/vmw_vsock/virtio_transport.c

F:	drivers/net/vsockmon.c

F:	drivers/vhost/vsock.c

F:	drivers/vhost/vsock.h

drivers/net/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -355,6 +355,14 @@ config NET_VRF 
	  This option enables the support for mapping interfaces into VRF's. The

	  support enables VRF devices.



config VSOCKMON

    tristate "Virtual vsock monitoring device"

    depends on VHOST_VSOCK

    ---help---

     This option enables a monitoring net device for vsock sockets. It is

     mostly intended for developers or support to debug vsock issues. If

     unsure, say N.



endif # NET_CORE



config SUNGEM_PHY

drivers/net/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ obj-$(CONFIG_GENEVE) += geneve.o 
obj-$(CONFIG_GTP) += gtp.o

obj-$(CONFIG_NLMON) += nlmon.o

obj-$(CONFIG_NET_VRF) += vrf.o

obj-$(CONFIG_VSOCKMON) += vsockmon.o



#

# Networking Drivers

drivers/net/vsockmon.c

0 → 100644
+170 −0
Original line number Diff line number Diff line 
#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/if_arp.h>

#include <net/rtnetlink.h>

#include <net/sock.h>

#include <net/af_vsock.h>

#include <uapi/linux/vsockmon.h>

#include <linux/virtio_vsock.h>



/* Virtio transport max packet size plus header */

#define DEFAULT_MTU (VIRTIO_VSOCK_MAX_PKT_BUF_SIZE + \

		     sizeof(struct af_vsockmon_hdr))



struct pcpu_lstats {

	u64 rx_packets;

	u64 rx_bytes;

	struct u64_stats_sync syncp;

};



static int vsockmon_dev_init(struct net_device *dev)

{

	dev->lstats = netdev_alloc_pcpu_stats(struct pcpu_lstats);

	if (!dev->lstats)

		return -ENOMEM;

	return 0;

}



static void vsockmon_dev_uninit(struct net_device *dev)

{

	free_percpu(dev->lstats);

}



struct vsockmon {

	struct vsock_tap vt;

};



static int vsockmon_open(struct net_device *dev)

{

	struct vsockmon *vsockmon = netdev_priv(dev);



	vsockmon->vt.dev = dev;

	vsockmon->vt.module = THIS_MODULE;

	return vsock_add_tap(&vsockmon->vt);

}



static int vsockmon_close(struct net_device *dev)

{

	struct vsockmon *vsockmon = netdev_priv(dev);



	return vsock_remove_tap(&vsockmon->vt);

}



static netdev_tx_t vsockmon_xmit(struct sk_buff *skb, struct net_device *dev)

{

	int len = skb->len;

	struct pcpu_lstats *stats = this_cpu_ptr(dev->lstats);



	u64_stats_update_begin(&stats->syncp);

	stats->rx_bytes += len;

	stats->rx_packets++;

	u64_stats_update_end(&stats->syncp);



	dev_kfree_skb(skb);



	return NETDEV_TX_OK;

}



static void

vsockmon_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)

{

	int i;

	u64 bytes = 0, packets = 0;



	for_each_possible_cpu(i) {

		const struct pcpu_lstats *vstats;

		u64 tbytes, tpackets;

		unsigned int start;



		vstats = per_cpu_ptr(dev->lstats, i);



		do {

			start = u64_stats_fetch_begin_irq(&vstats->syncp);

			tbytes = vstats->rx_bytes;

			tpackets = vstats->rx_packets;

		} while (u64_stats_fetch_retry_irq(&vstats->syncp, start));



		packets += tpackets;

		bytes += tbytes;

	}



	stats->rx_packets = packets;

	stats->tx_packets = 0;



	stats->rx_bytes = bytes;

	stats->tx_bytes = 0;

}



static int vsockmon_is_valid_mtu(int new_mtu)

{

	return new_mtu >= (int)sizeof(struct af_vsockmon_hdr);

}



static int vsockmon_change_mtu(struct net_device *dev, int new_mtu)

{

	if (!vsockmon_is_valid_mtu(new_mtu))

		return -EINVAL;



	dev->mtu = new_mtu;

	return 0;

}



static const struct net_device_ops vsockmon_ops = {

	.ndo_init = vsockmon_dev_init,

	.ndo_uninit = vsockmon_dev_uninit,

	.ndo_open = vsockmon_open,

	.ndo_stop = vsockmon_close,

	.ndo_start_xmit = vsockmon_xmit,

	.ndo_get_stats64 = vsockmon_get_stats64,

	.ndo_change_mtu = vsockmon_change_mtu,

};



static u32 always_on(struct net_device *dev)

{

	return 1;

}



static const struct ethtool_ops vsockmon_ethtool_ops = {

	.get_link = always_on,

};



static void vsockmon_setup(struct net_device *dev)

{

	dev->type = ARPHRD_VSOCKMON;

	dev->priv_flags |= IFF_NO_QUEUE;



	dev->netdev_ops	= &vsockmon_ops;

	dev->ethtool_ops = &vsockmon_ethtool_ops;

	dev->destructor	= free_netdev;



	dev->features = NETIF_F_SG | NETIF_F_FRAGLIST |

			NETIF_F_HIGHDMA | NETIF_F_LLTX;



	dev->flags = IFF_NOARP;



	dev->mtu = DEFAULT_MTU;

}



static struct rtnl_link_ops vsockmon_link_ops __read_mostly = {

	.kind			= "vsockmon",

	.priv_size		= sizeof(struct vsockmon),

	.setup			= vsockmon_setup,

};



static __init int vsockmon_register(void)

{

	return rtnl_link_register(&vsockmon_link_ops);

}



static __exit void vsockmon_unregister(void)

{

	rtnl_link_unregister(&vsockmon_link_ops);

}



module_init(vsockmon_register);

module_exit(vsockmon_unregister);



MODULE_LICENSE("GPL v2");

MODULE_AUTHOR("Gerard Garcia <ggarcia@deic.uab.cat>");

MODULE_DESCRIPTION("Vsock monitoring device. Based on nlmon device.");

MODULE_ALIAS_RTNL_LINK("vsockmon");

drivers/vhost/vsock.c

+8 −0
Original line number Diff line number Diff line
@@ -176,6 +176,11 @@ vhost_transport_do_send_pkt(struct vhost_vsock *vsock, 
				restart_tx = true;

		}



		/* Deliver to monitoring devices all correctly transmitted

		 * packets.

		 */

		virtio_transport_deliver_tap_pkt(pkt);



		virtio_transport_free_pkt(pkt);

	}

	if (added)
@@ -383,6 +388,9 @@ static void vhost_vsock_handle_tx_kick(struct vhost_work *work) 


		len = pkt->len;



		/* Deliver to monitoring devices all received packets */

		virtio_transport_deliver_tap_pkt(pkt);



		/* Only accept correctly addressed packets */

		if (le64_to_cpu(pkt->hdr.src_cid) == vsock->guest_cid)

			virtio_transport_recv_pkt(pkt);