Re: [PATCH v12 12/17] Add mp(mediate passthru) device.

[Michael S. Tsirkin]

On Thu, Sep 30, 2010 at 10:04:30PM +0800, xiaohui.xin@xxxxxxxxx wrote:
> From: Xin Xiaohui <xiaohui.xin@xxxxxxxxx>
> 
> The patch add mp(mediate passthru) device, which now
> based on vhost-net backend driver and provides proto_ops
> to send/receive guest buffers data from/to guest vitio-net
> driver.
> 
> Signed-off-by: Xin Xiaohui <xiaohui.xin@xxxxxxxxx>
> Signed-off-by: Zhao Yu <yzhao81new@xxxxxxxxx>
> Reviewed-by: Jeff Dike <jdike@xxxxxxxxxxxxxxx>

So you plan to rewrite all this to make this code part of macvtap?

> ---
>  drivers/vhost/mpassthru.c | 1380 +++++++++++++++++++++++++++++++++++++++++++++
>  1 files changed, 1380 insertions(+), 0 deletions(-)
>  create mode 100644 drivers/vhost/mpassthru.c
> 
> diff --git a/drivers/vhost/mpassthru.c b/drivers/vhost/mpassthru.c
> new file mode 100644
> index 0000000..1a114d1
> --- /dev/null
> +++ b/drivers/vhost/mpassthru.c
> @@ -0,0 +1,1380 @@
> +/*
> + *  MPASSTHRU - Mediate passthrough device.
> + *  Copyright (C) 2009 ZhaoYu, XinXiaohui, Dike, Jeffery G
> + *
> + *  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; either version 2 of the License, or
> + *  (at your option) any 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.
> + *
> + */
> +
> +#define DRV_NAME        "mpassthru"
> +#define DRV_DESCRIPTION "Mediate passthru device driver"
> +#define DRV_COPYRIGHT   "(C) 2009 ZhaoYu, XinXiaohui, Dike, Jeffery G"
> +
> +#include <linux/compat.h>
> +#include <linux/module.h>
> +#include <linux/errno.h>
> +#include <linux/kernel.h>
> +#include <linux/major.h>
> +#include <linux/slab.h>
> +#include <linux/smp_lock.h>
> +#include <linux/poll.h>
> +#include <linux/fcntl.h>
> +#include <linux/init.h>
> +#include <linux/aio.h>
> +
> +#include <linux/skbuff.h>
> +#include <linux/netdevice.h>
> +#include <linux/etherdevice.h>
> +#include <linux/miscdevice.h>
> +#include <linux/ethtool.h>
> +#include <linux/rtnetlink.h>
> +#include <linux/if.h>
> +#include <linux/if_arp.h>
> +#include <linux/if_ether.h>
> +#include <linux/crc32.h>
> +#include <linux/nsproxy.h>
> +#include <linux/uaccess.h>
> +#include <linux/virtio_net.h>
> +#include <linux/mpassthru.h>
> +#include <net/net_namespace.h>
> +#include <net/netns/generic.h>
> +#include <net/rtnetlink.h>
> +#include <net/sock.h>
> +
> +#include <asm/system.h>
> +
> +#define COPY_THRESHOLD (L1_CACHE_BYTES * 4)
> +#define COPY_HDR_LEN   (L1_CACHE_BYTES < 64 ? 64 : L1_CACHE_BYTES)
> +
> +struct frag {
> +	u16     offset;
> +	u16     size;
> +};
> +
> +#define	HASH_BUCKETS	(8192*2)
> +
> +struct page_info {
> +	struct list_head        list;
> +	struct page_info	*next;
> +	struct page_info	*prev;
> +	struct page             *pages[MAX_SKB_FRAGS];
> +	struct sk_buff          *skb;
> +	struct page_pool        *pool;
> +
> +	/* The pointer relayed to skb, to indicate
> +	 * it's a external allocated skb or kernel
> +	 */
> +	struct skb_ext_page    ext_page;
> +	/* flag to indicate read or write */
> +#define INFO_READ                      0
> +#define INFO_WRITE                     1
> +	unsigned                flags;
> +	/* exact number of locked pages */
> +	unsigned                pnum;
> +
> +	/* The fields after that is for backend
> +	 * driver, now for vhost-net.
> +	 */
> +	/* the kiocb structure related to */
> +	struct kiocb            *iocb;
> +	/* the ring descriptor index */
> +	unsigned int            desc_pos;
> +	/* the iovec coming from backend, we only
> +	* need few of them */
> +	struct iovec            hdr[2];
> +	struct iovec            iov[2];
> +};
> +
> +static struct kmem_cache *ext_page_info_cache;
> +
> +struct page_pool {
> +	/* the queue for rx side */
> +	struct list_head        readq;
> +	/* the lock to protect readq */
> +	spinlock_t		read_lock;
> +	/* record the orignal rlimit */
> +	struct rlimit		o_rlim;
> +	/* record the locked pages */
> +	int			lock_pages;
> +	/* the device according to */
> +	struct net_device	*dev;
> +	/* the mp_port according to dev */
> +	struct mp_port		port;
> +	/* the hash_table list to find each locked page */
> +	struct page_info	**hash_table;
> +};
> +
> +struct mp_struct {
> +	struct mp_file		*mfile;
> +	struct net_device       *dev;
> +	struct page_pool	*pool;
> +	struct socket           socket;
> +};
> +
> +struct mp_file {
> +	atomic_t count;
> +	struct mp_struct *mp;
> +	struct net *net;
> +};
> +
> +struct mp_sock {
> +	struct sock		sk;
> +	struct mp_struct	*mp;
> +};
> +
> +/* The main function to allocate external buffers */
> +static struct skb_ext_page *page_ctor(struct mp_port *port,
> +				      struct sk_buff *skb,
> +				      int npages)
> +{
> +	int i;
> +	unsigned long flags;
> +	struct page_pool *pool;
> +	struct page_info *info = NULL;
> +
> +	if (npages != 1)
> +		BUG();
> +	pool = container_of(port, struct page_pool, port);
> +
> +	spin_lock_irqsave(&pool->read_lock, flags);
> +	if (!list_empty(&pool->readq)) {
> +		info = list_first_entry(&pool->readq, struct page_info, list);
> +		list_del(&info->list);
> +	}
> +	spin_unlock_irqrestore(&pool->read_lock, flags);
> +	if (!info)
> +		return NULL;
> +
> +	for (i = 0; i < info->pnum; i++)
> +		get_page(info->pages[i]);
> +	info->skb = skb;
> +	return &info->ext_page;
> +}
> +
> +static struct page_info *mp_hash_lookup(struct page_pool *pool,
> +					struct page *page);
> +static struct page_info *mp_hash_delete(struct page_pool *pool,
> +					struct page_info *info);
> +
> +static struct skb_ext_page *mp_lookup(struct net_device *dev,
> +				      struct page *page)
> +{
> +	struct mp_struct *mp =
> +		container_of(dev->mp_port->sock->sk, struct mp_sock, sk)->mp;
> +	struct page_pool *pool = mp->pool;
> +	struct page_info *info;
> +
> +	info = mp_hash_lookup(pool, page);
> +	if (!info)
> +		return NULL;
> +	return &info->ext_page;
> +}
> +
> +static int page_pool_attach(struct mp_struct *mp)
> +{
> +	int rc;
> +	struct page_pool *pool;
> +	struct net_device *dev = mp->dev;
> +
> +	/* locked by mp_mutex */
> +	if (mp->pool)
> +		return -EBUSY;
> +
> +	pool = kzalloc(sizeof(*pool), GFP_KERNEL);
> +	if (!pool)
> +		return -ENOMEM;
> +	rc = netdev_mp_port_prep(dev, &pool->port);
> +	if (rc)
> +		goto fail;
> +
> +	INIT_LIST_HEAD(&pool->readq);
> +	spin_lock_init(&pool->read_lock);
> +	pool->hash_table = kzalloc(sizeof(struct page_info *) * HASH_BUCKETS,
> +			GFP_KERNEL);
> +	if (!pool->hash_table)
> +		goto fail;
> +
> +	dev_hold(dev);
> +	pool->dev = dev;
> +	pool->port.ctor = page_ctor;
> +	pool->port.sock = &mp->socket;
> +	pool->port.hash = mp_lookup;
> +	pool->lock_pages = 0;
> +
> +	/* locked by mp_mutex */
> +	dev->mp_port = &pool->port;
> +	mp->pool = pool;
> +
> +	return 0;
> +
> +fail:
> +	kfree(pool);
> +	dev_put(dev);
> +
> +	return rc;
> +}
> +
> +struct page_info *info_dequeue(struct page_pool *pool)
> +{
> +	unsigned long flags;
> +	struct page_info *info = NULL;
> +	spin_lock_irqsave(&pool->read_lock, flags);
> +	if (!list_empty(&pool->readq)) {
> +		info = list_first_entry(&pool->readq,
> +				struct page_info, list);
> +		list_del(&info->list);
> +	}
> +	spin_unlock_irqrestore(&pool->read_lock, flags);
> +	return info;
> +}
> +
> +static int set_memlock_rlimit(struct page_pool *pool, int resource,
> +			      unsigned long cur, unsigned long max)
> +{
> +	struct rlimit new_rlim, *old_rlim;
> +	int retval;
> +
> +	if (resource != RLIMIT_MEMLOCK)
> +		return -EINVAL;
> +	new_rlim.rlim_cur = cur;
> +	new_rlim.rlim_max = max;
> +
> +	old_rlim = current->signal->rlim + resource;
> +
> +	/* remember the old rlimit value when backend enabled */
> +	pool->o_rlim.rlim_cur = old_rlim->rlim_cur;
> +	pool->o_rlim.rlim_max = old_rlim->rlim_max;
> +
> +	if ((new_rlim.rlim_max > old_rlim->rlim_max) &&
> +			!capable(CAP_SYS_RESOURCE))
> +		return -EPERM;
> +
> +	retval = security_task_setrlimit(resource, &new_rlim);
> +	if (retval)
> +		return retval;
> +
> +	task_lock(current->group_leader);
> +	*old_rlim = new_rlim;
> +	task_unlock(current->group_leader);
> +	return 0;
> +}
> +
> +static void mp_ki_dtor(struct kiocb *iocb)
> +{
> +	struct page_info *info = (struct page_info *)(iocb->private);
> +	int i;
> +
> +	if (info->flags == INFO_READ) {
> +		for (i = 0; i < info->pnum; i++) {
> +			if (info->pages[i]) {
> +				set_page_dirty_lock(info->pages[i]);
> +				put_page(info->pages[i]);
> +			}
> +		}
> +		mp_hash_delete(info->pool, info);
> +		if (info->skb) {
> +			info->skb->destructor = NULL;
> +			kfree_skb(info->skb);
> +		}
> +	}
> +	/* Decrement the number of locked pages */
> +	info->pool->lock_pages -= info->pnum;
> +	kmem_cache_free(ext_page_info_cache, info);
> +
> +	return;
> +}
> +
> +static struct kiocb *create_iocb(struct page_info *info, int size)
> +{
> +	struct kiocb *iocb = NULL;
> +
> +	iocb = info->iocb;
> +	if (!iocb)
> +		return iocb;
> +	iocb->ki_flags = 0;
> +	iocb->ki_users = 1;
> +	iocb->ki_key = 0;
> +	iocb->ki_ctx = NULL;
> +	iocb->ki_cancel = NULL;
> +	iocb->ki_retry = NULL;
> +	iocb->ki_eventfd = NULL;
> +	iocb->ki_pos = info->desc_pos;
> +	iocb->ki_nbytes = size;
> +	iocb->ki_dtor(iocb);
> +	iocb->private = (void *)info;
> +	iocb->ki_dtor = mp_ki_dtor;
> +
> +	return iocb;
> +}
> +
> +static int page_pool_detach(struct mp_struct *mp)
> +{
> +	struct page_pool *pool;
> +	struct page_info *info;
> +	int i;
> +
> +	/* locked by mp_mutex */
> +	pool = mp->pool;
> +	if (!pool)
> +		return -ENODEV;
> +
> +	while ((info = info_dequeue(pool))) {
> +		for (i = 0; i < info->pnum; i++)
> +			if (info->pages[i])
> +				put_page(info->pages[i]);
> +		create_iocb(info, 0);
> +		kmem_cache_free(ext_page_info_cache, info);
> +	}
> +
> +	set_memlock_rlimit(pool, RLIMIT_MEMLOCK,
> +			   pool->o_rlim.rlim_cur,
> +			   pool->o_rlim.rlim_max);
> +
> +	/* locked by mp_mutex */
> +	pool->dev->mp_port = NULL;
> +	dev_put(pool->dev);
> +
> +	mp->pool = NULL;
> +	kfree(pool->hash_table);
> +	kfree(pool);
> +	return 0;
> +}
> +
> +static void __mp_detach(struct mp_struct *mp)
> +{
> +	mp->mfile = NULL;
> +
> +	dev_change_flags(mp->dev, mp->dev->flags & ~IFF_UP);
> +	page_pool_detach(mp);
> +	dev_change_flags(mp->dev, mp->dev->flags | IFF_UP);
> +
> +	/* Drop the extra count on the net device */
> +	dev_put(mp->dev);
> +}
> +
> +static DEFINE_MUTEX(mp_mutex);
> +
> +static void mp_detach(struct mp_struct *mp)
> +{
> +	mutex_lock(&mp_mutex);
> +	__mp_detach(mp);
> +	mutex_unlock(&mp_mutex);
> +}
> +
> +static struct mp_struct *mp_get(struct mp_file *mfile)
> +{
> +	struct mp_struct *mp = NULL;
> +	if (atomic_inc_not_zero(&mfile->count))
> +		mp = mfile->mp;
> +
> +	return mp;
> +}
> +
> +static void mp_put(struct mp_file *mfile)
> +{
> +	if (atomic_dec_and_test(&mfile->count)) {
> +		if (!rtnl_is_locked()) {
> +			rtnl_lock();
> +			mp_detach(mfile->mp);
> +			rtnl_unlock();
> +		} else
> +			mp_detach(mfile->mp);
> +	}
> +}
> +
> +static void iocb_tag(struct kiocb *iocb)
> +{
> +	iocb->ki_flags = 1;
> +}
> +
> +/* The callback to destruct the external buffers or skb */
> +static void page_dtor(struct skb_ext_page *ext_page)
> +{
> +	struct page_info *info;
> +	struct page_pool *pool;
> +	struct sock *sk;
> +	struct sk_buff *skb;
> +
> +	if (!ext_page)
> +		return;
> +	info = container_of(ext_page, struct page_info, ext_page);
> +	if (!info)
> +		return;
> +	pool = info->pool;
> +	skb = info->skb;
> +
> +	if (info->flags == INFO_READ) {
> +		create_iocb(info, 0);
> +		return;
> +	}
> +
> +	/* For transmit, we should wait for the DMA finish by hardware.
> +	 * Queue the notifier to wake up the backend driver
> +	 */
> +
> +	iocb_tag(info->iocb);
> +	sk = pool->port.sock->sk;
> +	sk->sk_write_space(sk);
> +
> +	return;
> +}
> +
> +/* For small exteranl buffers transmit, we don't need to call
> + * get_user_pages().
> + */
> +static struct page_info *alloc_small_page_info(struct page_pool *pool,
> +		struct kiocb *iocb, int total)
> +{
> +	struct page_info *info =
> +		kmem_cache_alloc(ext_page_info_cache, GFP_KERNEL);
> +
> +	if (!info)
> +		return NULL;
> +	info->ext_page.dtor = page_dtor;
> +	info->pool = pool;
> +	info->flags = INFO_WRITE;
> +	info->iocb = iocb;
> +	info->pnum = 0;
> +	return info;
> +}
> +
> +typedef u32 key_mp_t;
> +static inline key_mp_t mp_hash(struct page *page, int buckets)
> +{
> +	key_mp_t k;
> +#if BITS_PER_LONG == 64
> +	k = ((((unsigned long)page << 32UL) >> 32UL) /
> +			sizeof(struct page)) % buckets ;
> +#elif BITS_PER_LONG == 32
> +	k = ((unsigned long)page / sizeof(struct page)) % buckets;
> +#endif
> +
> +	return k;
> +}
> +
> +static void mp_hash_insert(struct page_pool *pool,
> +		struct page *page, struct page_info *page_info)
> +{
> +	struct page_info *tmp;
> +	key_mp_t key = mp_hash(page, HASH_BUCKETS);
> +	if (!pool->hash_table[key]) {
> +		pool->hash_table[key] = page_info;
> +		return;
> +	}
> +
> +	tmp = pool->hash_table[key];
> +	while (tmp->next)
> +		tmp = tmp->next;
> +
> +	tmp->next = page_info;
> +	page_info->prev = tmp;
> +	return;
> +}
> +
> +static struct page_info *mp_hash_delete(struct page_pool *pool,
> +					struct page_info *info)
> +{
> +	key_mp_t key = mp_hash(info->pages[0], HASH_BUCKETS);
> +	struct page_info *tmp = NULL;
> +
> +	tmp = pool->hash_table[key];
> +	while (tmp) {
> +		if (tmp == info) {
> +			if (!tmp->prev) {
> +				pool->hash_table[key] = tmp->next;
> +				if (tmp->next)
> +					tmp->next->prev = NULL;
> +			} else {
> +				tmp->prev->next = tmp->next;
> +				if (tmp->next)
> +					tmp->next->prev = tmp->prev;
> +			}
> +			return tmp;
> +		}
> +		tmp = tmp->next;
> +	}
> +	return tmp;
> +}
> +
> +static struct page_info *mp_hash_lookup(struct page_pool *pool,
> +					struct page *page)
> +{
> +	key_mp_t key = mp_hash(page, HASH_BUCKETS);
> +	struct page_info *tmp = NULL;
> +
> +	int i;
> +	tmp = pool->hash_table[key];
> +	while (tmp) {
> +		for (i = 0; i < tmp->pnum; i++) {
> +			if (tmp->pages[i] == page)
> +				return tmp;
> +		}
> +		tmp = tmp->next;
> +	}
> +	return tmp;
> +}
> +
> +/* The main function to transform the guest user space address
> + * to host kernel address via get_user_pages(). Thus the hardware
> + * can do DMA directly to the external buffer address.
> + */
> +static struct page_info *alloc_page_info(struct page_pool *pool,
> +		struct kiocb *iocb, struct iovec *iov,
> +		int count, struct frag *frags,
> +		int npages, int total)
> +{
> +	int rc;
> +	int i, j, n = 0;
> +	int len;
> +	unsigned long base, lock_limit;
> +	struct page_info *info = NULL;
> +
> +	lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
> +	lock_limit >>= PAGE_SHIFT;
> +
> +	if (pool->lock_pages + count > lock_limit && npages) {
> +		printk(KERN_INFO "exceed the locked memory rlimit.");
> +		return NULL;
> +	}
> +
> +	info = kmem_cache_alloc(ext_page_info_cache, GFP_KERNEL);
> +	
> +	if (!info)
> +		return NULL;
> +	info->skb = NULL;
> +	info->next = info->prev = NULL;
> +
> +	for (i = j = 0; i < count; i++) {
> +		base = (unsigned long)iov[i].iov_base;
> +		len = iov[i].iov_len;
> +
> +		if (!len)
> +			continue;
> +		n = ((base & ~PAGE_MASK) + len + ~PAGE_MASK) >> PAGE_SHIFT;
> +
> +		rc = get_user_pages_fast(base, n, npages ? 1 : 0,
> +				&info->pages[j]);
> +		if (rc != n)
> +			goto failed;
> +
> +		while (n--) {
> +			frags[j].offset = base & ~PAGE_MASK;
> +			frags[j].size = min_t(int, len,
> +					PAGE_SIZE - frags[j].offset);
> +			len -= frags[j].size;
> +			base += frags[j].size;
> +			j++;
> +		}
> +	}
> +
> +#ifdef CONFIG_HIGHMEM
> +	if (npages && !(dev->features & NETIF_F_HIGHDMA)) {
> +		for (i = 0; i < j; i++) {
> +			if (PageHighMem(info->pages[i]))
> +				goto failed;
> +		}
> +	}
> +#endif
> +
> +	info->ext_page.dtor = page_dtor;
> +	info->ext_page.page = info->pages[0];
> +	info->pool = pool;
> +	info->pnum = j;
> +	info->iocb = iocb;
> +	if (!npages)
> +		info->flags = INFO_WRITE;
> +	else
> +		info->flags = INFO_READ;
> +
> +	if (info->flags == INFO_READ) {
> +		if (frags[0].offset == 0 && iocb->ki_iovec[0].iov_len) {
> +			frags[0].offset = iocb->ki_iovec[0].iov_len;
> +			pool->port.vnet_hlen = iocb->ki_iovec[0].iov_len;
> +		}
> +		for (i = 0; i < j; i++)
> +			mp_hash_insert(pool, info->pages[i], info);
> +	}
> +	/* increment the number of locked pages */
> +	pool->lock_pages += j;
> +	return info;
> +
> +failed:
> +	for (i = 0; i < j; i++)
> +		put_page(info->pages[i]);
> +
> +	kmem_cache_free(ext_page_info_cache, info);
> +
> +	return NULL;
> +}
> +
> +static void mp_sock_destruct(struct sock *sk)
> +{
> +	struct mp_struct *mp = container_of(sk, struct mp_sock, sk)->mp;
> +	kfree(mp);
> +}
> +
> +static void mp_sock_state_change(struct sock *sk)
> +{
> +	if (sk_has_sleeper(sk))
> +		wake_up_interruptible_sync_poll(sk->sk_sleep, POLLIN);
> +}
> +
> +static void mp_sock_write_space(struct sock *sk)
> +{
> +	if (sk_has_sleeper(sk))
> +		wake_up_interruptible_sync_poll(sk->sk_sleep, POLLOUT);
> +}
> +
> +static void mp_sock_data_ready(struct sock *sk, int coming)
> +{
> +	struct mp_struct *mp = container_of(sk, struct mp_sock, sk)->mp;
> +	struct page_pool *pool = NULL;
> +	struct sk_buff *skb = NULL;
> +	struct page_info *info = NULL;
> +	int len;
> +
> +	pool = mp->pool;
> +	if (!pool)
> +		return;
> +
> +	while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
> +		struct page *page;
> +		int off;
> +		int size = 0, i = 0;
> +		struct skb_shared_info *shinfo = skb_shinfo(skb);
> +		struct skb_ext_page *ext_page =
> +			(struct skb_ext_page *)(shinfo->destructor_arg);
> +		struct virtio_net_hdr_mrg_rxbuf hdr = {
> +			.hdr.flags = 0,
> +			.hdr.gso_type = VIRTIO_NET_HDR_GSO_NONE
> +		};
> +
> +		if (skb->ip_summed == CHECKSUM_COMPLETE)
> +			printk(KERN_INFO "Complete checksum occurs\n");
> +
> +		if (shinfo->frags[0].page == ext_page->page) {
> +			info = container_of(ext_page,
> +					    struct page_info,
> +					    ext_page);
> +			if (shinfo->nr_frags)
> +				hdr.num_buffers = shinfo->nr_frags;
> +			else
> +				hdr.num_buffers = shinfo->nr_frags + 1;
> +		} else {
> +			info = container_of(ext_page,
> +					    struct page_info,
> +					    ext_page);
> +			hdr.num_buffers = shinfo->nr_frags + 1;
> +		}
> +		skb_push(skb, ETH_HLEN);
> +
> +		if (skb_is_gso(skb)) {
> +			hdr.hdr.hdr_len = skb_headlen(skb);
> +			hdr.hdr.gso_size = shinfo->gso_size;
> +			if (shinfo->gso_type & SKB_GSO_TCPV4)
> +				hdr.hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
> +			else if (shinfo->gso_type & SKB_GSO_TCPV6)
> +				hdr.hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
> +			else if (shinfo->gso_type & SKB_GSO_UDP)
> +				hdr.hdr.gso_type = VIRTIO_NET_HDR_GSO_UDP;
> +			else
> +				BUG();
> +			if (shinfo->gso_type & SKB_GSO_TCP_ECN)
> +				hdr.hdr.gso_type |= VIRTIO_NET_HDR_GSO_ECN;
> +
> +		} else
> +			hdr.hdr.gso_type = VIRTIO_NET_HDR_GSO_NONE;
> +
> +		if (skb->ip_summed == CHECKSUM_PARTIAL) {
> +			hdr.hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
> +			hdr.hdr.csum_start =
> +				skb->csum_start - skb_headroom(skb);
> +			hdr.hdr.csum_offset = skb->csum_offset;
> +		}
> +
> +		off = info->hdr[0].iov_len;
> +		len = memcpy_toiovec(info->iov, (unsigned char *)&hdr, off);
> +		if (len) {
> +			pr_debug("Unable to write vnet_hdr at addr '%p': '%d'\n",
> +				info->iov, len);
> +			goto clean;
> +		}
> +
> +		memcpy_toiovec(info->iov, skb->data, skb_headlen(skb));
> +
> +		info->iocb->ki_left = hdr.num_buffers;
> +		if (shinfo->frags[0].page == ext_page->page) {
> +			size = shinfo->frags[0].size +
> +				shinfo->frags[0].page_offset - off;
> +			i = 1;
> +		} else {
> +			size = skb_headlen(skb);
> +			i = 0;
> +		}
> +		create_iocb(info, off + size);
> +		for (i = i; i < shinfo->nr_frags; i++) {
> +			page = shinfo->frags[i].page;
> +			info = mp_hash_lookup(pool, shinfo->frags[i].page);
> +			create_iocb(info, shinfo->frags[i].size);
> +		}
> +		info->skb = skb;
> +		shinfo->nr_frags = 0;
> +		shinfo->destructor_arg = NULL;
> +		continue;
> +clean:
> +		kfree_skb(skb);
> +		for (i = 0; i < info->pnum; i++)
> +			put_page(info->pages[i]);
> +		kmem_cache_free(ext_page_info_cache, info);
> +	}
> +	return;
> +}
> +
> +static inline struct sk_buff *mp_alloc_skb(struct sock *sk, size_t prepad,
> +					   size_t len, size_t linear,
> +					   int noblock, int *err)
> +{
> +	struct sk_buff *skb;
> +
> +	/* Under a page?  Don't bother with paged skb. */
> +	if (prepad + len < PAGE_SIZE || !linear)
> +		linear = len;
> +
> +	skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock,
> +			err);
> +	if (!skb)
> +		return NULL;
> +
> +	skb_reserve(skb, prepad);
> +	skb_put(skb, linear);
> +	skb->data_len = len - linear;
> +	skb->len += len - linear;
> +
> +	return skb;
> +}
> +
> +static int mp_skb_from_vnet_hdr(struct sk_buff *skb,
> +		struct virtio_net_hdr *vnet_hdr)
> +{
> +	unsigned short gso_type = 0;
> +	if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
> +		switch (vnet_hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
> +		case VIRTIO_NET_HDR_GSO_TCPV4:
> +			gso_type = SKB_GSO_TCPV4;
> +			break;
> +		case VIRTIO_NET_HDR_GSO_TCPV6:
> +			gso_type = SKB_GSO_TCPV6;
> +			break;
> +		case VIRTIO_NET_HDR_GSO_UDP:
> +			gso_type = SKB_GSO_UDP;
> +			break;
> +		default:
> +			return -EINVAL;
> +		}
> +
> +		if (vnet_hdr->gso_type & VIRTIO_NET_HDR_GSO_ECN)
> +			gso_type |= SKB_GSO_TCP_ECN;
> +
> +		if (vnet_hdr->gso_size == 0)
> +			return -EINVAL;
> +	}
> +
> +	if (vnet_hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
> +		if (!skb_partial_csum_set(skb, vnet_hdr->csum_start,
> +					vnet_hdr->csum_offset))
> +			return -EINVAL;
> +	}
> +
> +	if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
> +		skb_shinfo(skb)->gso_size = vnet_hdr->gso_size;
> +		skb_shinfo(skb)->gso_type = gso_type;
> +
> +		/* Header must be checked, and gso_segs computed. */
> +		skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
> +		skb_shinfo(skb)->gso_segs = 0;
> +	}
> +	return 0;
> +}
> +
> +static int mp_sendmsg(struct kiocb *iocb, struct socket *sock,
> +		struct msghdr *m, size_t total_len)
> +{
> +	struct mp_struct *mp = container_of(sock->sk, struct mp_sock, sk)->mp;
> +	struct virtio_net_hdr vnet_hdr = {0};
> +	int hdr_len = 0;
> +	struct page_pool *pool;
> +	struct iovec *iov = m->msg_iov;
> +	struct page_info *info = NULL;
> +	struct frag frags[MAX_SKB_FRAGS];
> +	struct sk_buff *skb;
> +	int count = m->msg_iovlen;
> +	int total = 0, header, n, i, len, rc;
> +	unsigned long base;
> +
> +	pool = mp->pool;
> +	if (!pool)
> +		return -ENODEV;
> +
> +	total = iov_length(iov, count);
> +
> +	if (total < ETH_HLEN)
> +		return -EINVAL;
> +
> +	if (total <= COPY_THRESHOLD)
> +		goto copy;
> +
> +	n = 0;
> +	for (i = 0; i < count; i++) {
> +		base = (unsigned long)iov[i].iov_base;
> +		len = iov[i].iov_len;
> +		if (!len)
> +			continue;
> +		n += ((base & ~PAGE_MASK) + len + ~PAGE_MASK) >> PAGE_SHIFT;
> +		if (n > MAX_SKB_FRAGS)
> +			return -EINVAL;
> +	}
> +
> +copy:
> +	hdr_len = sizeof(vnet_hdr);
> +	if ((total - iocb->ki_iovec[0].iov_len) < 0)
> +		return -EINVAL;
> +
> +	rc = memcpy_fromiovecend((void *)&vnet_hdr, iocb->ki_iovec, 0, hdr_len);
> +	if (rc < 0)
> +		return -EINVAL;
> +
> +	if ((vnet_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
> +			vnet_hdr.csum_start + vnet_hdr.csum_offset + 2 >
> +			vnet_hdr.hdr_len)
> +		vnet_hdr.hdr_len = vnet_hdr.csum_start +
> +			vnet_hdr.csum_offset + 2;
> +
> +	if (vnet_hdr.hdr_len > total)
> +		return -EINVAL;
> +
> +	header = total > COPY_THRESHOLD ? COPY_HDR_LEN : total;
> +
> +	skb = mp_alloc_skb(sock->sk, NET_IP_ALIGN, header,
> +			   iocb->ki_iovec[0].iov_len, 1, &rc);
> +
> +	if (!skb)
> +		goto drop;
> +
> +	skb_set_network_header(skb, ETH_HLEN);
> +	memcpy_fromiovec(skb->data, iov, header);
> +
> +	skb_reset_mac_header(skb);
> +	skb->protocol = eth_hdr(skb)->h_proto;
> +
> +	rc = mp_skb_from_vnet_hdr(skb, &vnet_hdr);
> +	if (rc)
> +		goto drop;
> +
> +	if (header == total) {
> +		rc = total;
> +		info = alloc_small_page_info(pool, iocb, total);
> +	} else {
> +		info = alloc_page_info(pool, iocb, iov, count, frags, 0, total);
> +		if (info)
> +			for (i = 0; i < info->pnum; i++) {
> +				skb_add_rx_frag(skb, i, info->pages[i],
> +						frags[i].offset, frags[i].size);
> +				info->pages[i] = NULL;
> +			}
> +	}
> +	if (!pool->lock_pages)
> +		sock->sk->sk_state_change(sock->sk);
> +
> +	if (info != NULL) {
> +		info->desc_pos = iocb->ki_pos;
> +		info->skb = skb;
> +		skb_shinfo(skb)->destructor_arg = &info->ext_page;
> +		skb->dev = mp->dev;
> +		create_iocb(info, total);
> +		dev_queue_xmit(skb);
> +		return 0;
> +	}
> +drop:
> +	kfree_skb(skb);
> +	if (info) {
> +		for (i = 0; i < info->pnum; i++)
> +			put_page(info->pages[i]);
> +		kmem_cache_free(ext_page_info_cache, info);
> +	}
> +	mp->dev->stats.tx_dropped++;
> +	return -ENOMEM;
> +}
> +
> +static int mp_recvmsg(struct kiocb *iocb, struct socket *sock,
> +		struct msghdr *m, size_t total_len,
> +		int flags)
> +{
> +	struct mp_struct *mp = container_of(sock->sk, struct mp_sock, sk)->mp;
> +	struct page_pool *pool;
> +	struct iovec *iov = m->msg_iov;
> +	int count = m->msg_iovlen;
> +	int npages, payload;
> +	struct page_info *info;
> +	struct frag frags[MAX_SKB_FRAGS];
> +	unsigned long base;
> +	int i, len;
> +	unsigned long flag;
> +
> +	if (!(flags & MSG_DONTWAIT))
> +		return -EINVAL;
> +
> +	pool = mp->pool;
> +	if (!pool)
> +		return -EINVAL;
> +
> +	/* Error detections in case invalid external buffer */
> +	if (count > 2 && iov[1].iov_len < pool->port.hdr_len &&
> +			mp->dev->features & NETIF_F_SG) {
> +		return -EINVAL;
> +	}
> +
> +	npages = pool->port.npages;
> +	payload = pool->port.data_len;
> +
> +	/* If KVM guest virtio-net FE driver use SG feature */
> +	if (count > 2) {
> +		for (i = 2; i < count; i++) {
> +			base = (unsigned long)iov[i].iov_base & ~PAGE_MASK;
> +			len = iov[i].iov_len;
> +			if (npages == 1)
> +				len = min_t(int, len, PAGE_SIZE - base);
> +			else if (base)
> +				break;
> +			payload -= len;
> +			if (payload <= 0)
> +				goto proceed;
> +			if (npages == 1 || (len & ~PAGE_MASK))
> +				break;
> +		}
> +	}
> +
> +	if ((((unsigned long)iov[1].iov_base & ~PAGE_MASK)
> +				- NET_SKB_PAD - NET_IP_ALIGN) >= 0)
> +		goto proceed;
> +
> +	return -EINVAL;
> +
> +proceed:
> +	/* skip the virtnet head */
> +	if (count > 1) {
> +		iov++;
> +		count--;
> +	}
> +
> +	if (!pool->lock_pages) {
> +		set_memlock_rlimit(pool, RLIMIT_MEMLOCK,
> +				iocb->ki_user_data * 4096 * 2,
> +				iocb->ki_user_data * 4096 * 2);
> +	}
> +
> +	/* Translate address to kernel */
> +	info = alloc_page_info(pool, iocb, iov, count, frags, npages, 0);
> +	if (!info)
> +		return -ENOMEM;
> +	info->hdr[0].iov_base = iocb->ki_iovec[0].iov_base;
> +	info->hdr[0].iov_len = iocb->ki_iovec[0].iov_len;
> +	iocb->ki_iovec[0].iov_len = 0;
> +	iocb->ki_left = 0;
> +	info->desc_pos = iocb->ki_pos;
> +
> +	if (count > 1) {
> +		iov--;
> +		count++;
> +	}
> +
> +	memcpy(info->iov, iov, sizeof(struct iovec) * count);
> +
> +	spin_lock_irqsave(&pool->read_lock, flag);
> +	list_add_tail(&info->list, &pool->readq);
> +	spin_unlock_irqrestore(&pool->read_lock, flag);
> +
> +	return 0;
> +}
> +
> +/* Ops structure to mimic raw sockets with mp device */
> +static const struct proto_ops mp_socket_ops = {
> +	.sendmsg = mp_sendmsg,
> +	.recvmsg = mp_recvmsg,
> +};
> +
> +static struct proto mp_proto = {
> +	.name           = "mp",
> +	.owner          = THIS_MODULE,
> +	.obj_size       = sizeof(struct mp_sock),
> +};
> +
> +static int mp_chr_open(struct inode *inode, struct file * file)
> +{
> +	struct mp_file *mfile;
> +	cycle_kernel_lock();
> +
> +	pr_debug("mp: mp_chr_open\n");
> +	mfile = kzalloc(sizeof(*mfile), GFP_KERNEL);
> +	if (!mfile)
> +		return -ENOMEM;
> +	atomic_set(&mfile->count, 0);
> +	mfile->mp = NULL;
> +	mfile->net = get_net(current->nsproxy->net_ns);
> +	file->private_data = mfile;
> +	return 0;
> +}
> +
> +static int mp_attach(struct mp_struct *mp, struct file *file)
> +{
> +	struct mp_file *mfile = file->private_data;
> +	int err;
> +
> +	netif_tx_lock_bh(mp->dev);
> +
> +	err = -EINVAL;
> +
> +	if (mfile->mp)
> +		goto out;
> +
> +	err = -EBUSY;
> +	if (mp->mfile)
> +		goto out;
> +
> +	err = 0;
> +	mfile->mp = mp;
> +	mp->mfile = mfile;
> +	mp->socket.file = file;
> +	dev_hold(mp->dev);
> +	sock_hold(mp->socket.sk);
> +	atomic_inc(&mfile->count);
> +
> +out:
> +	netif_tx_unlock_bh(mp->dev);
> +	return err;
> +}
> +
> +static int do_unbind(struct mp_file *mfile)
> +{
> +	struct mp_struct *mp = mp_get(mfile);
> +
> +	if (!mp)
> +		return -EINVAL;
> +
> +	mp_detach(mp);
> +	sock_put(mp->socket.sk);
> +	mp_put(mfile);
> +	return 0;
> +}
> +
> +static long mp_chr_ioctl(struct file *file, unsigned int cmd,
> +		unsigned long arg)
> +{
> +	struct mp_file *mfile = file->private_data;
> +	struct mp_struct *mp;
> +	struct net_device *dev;
> +	void __user* argp = (void __user *)arg;
> +	struct ifreq ifr;
> +	struct sock *sk;
> +	int ret;
> +
> +	ret = -EINVAL;
> +
> +	switch (cmd) {
> +	case MPASSTHRU_BINDDEV:
> +		ret = -EFAULT;
> +		if (copy_from_user(&ifr, argp, sizeof ifr))
> +			break;
> +
> +		ifr.ifr_name[IFNAMSIZ-1] = '\0';
> +
> +		ret = -ENODEV;
> +
> +		rtnl_lock();
> +		dev = dev_get_by_name(mfile->net, ifr.ifr_name);
> +		if (!dev) {
> +			rtnl_unlock();
> +			break;
> +		}
> +
> +		mutex_lock(&mp_mutex);
> +
> +		ret = -EBUSY;
> +
> +		/* the device can be only bind once */
> +		if (dev_is_mpassthru(dev))
> +			goto err_dev_put;
> +
> +		mp = mfile->mp;
> +		if (mp)
> +			goto err_dev_put;
> +
> +		mp = kzalloc(sizeof(*mp), GFP_KERNEL);
> +		if (!mp) {
> +			ret = -ENOMEM;
> +			goto err_dev_put;
> +		}
> +		mp->dev = dev;
> +		ret = -ENOMEM;
> +
> +		sk = sk_alloc(mfile->net, AF_UNSPEC, GFP_KERNEL, &mp_proto);
> +		if (!sk)
> +			goto err_free_mp;
> +
> +		init_waitqueue_head(&mp->socket.wait);
> +		mp->socket.ops = &mp_socket_ops;
> +		sock_init_data(&mp->socket, sk);
> +		sk->sk_sndbuf = INT_MAX;
> +		container_of(sk, struct mp_sock, sk)->mp = mp;
> +
> +		sk->sk_destruct = mp_sock_destruct;
> +		sk->sk_data_ready = mp_sock_data_ready;
> +		sk->sk_write_space = mp_sock_write_space;
> +		sk->sk_state_change = mp_sock_state_change;
> +		ret = mp_attach(mp, file);
> +		if (ret < 0)
> +			goto err_free_sk;
> +
> +		ret = page_pool_attach(mp);
> +		if (ret < 0)
> +			goto err_free_sk;
> +		dev_change_flags(mp->dev, mp->dev->flags & (~IFF_UP));
> +		dev_change_flags(mp->dev, mp->dev->flags | IFF_UP);
> +		sk->sk_state_change(sk);
> +out:
> +		mutex_unlock(&mp_mutex);
> +		rtnl_unlock();
> +		break;
> +err_free_sk:
> +		sk_free(sk);
> +err_free_mp:
> +		kfree(mp);
> +err_dev_put:
> +		dev_put(dev);
> +		goto out;
> +
> +	case MPASSTHRU_UNBINDDEV:
> +		rtnl_lock();
> +		ret = do_unbind(mfile);
> +		rtnl_unlock();
> +		break;
> +
> +	default:
> +		break;
> +	}
> +	return ret;
> +}
> +
> +static unsigned int mp_chr_poll(struct file *file, poll_table * wait)
> +{
> +	struct mp_file *mfile = file->private_data;
> +	struct mp_struct *mp = mp_get(mfile);
> +	struct sock *sk;
> +	unsigned int mask = 0;
> +
> +	if (!mp)
> +		return POLLERR;
> +
> +	sk = mp->socket.sk;
> +
> +	poll_wait(file, &mp->socket.wait, wait);
> +
> +	if (!skb_queue_empty(&sk->sk_receive_queue))
> +		mask |= POLLIN | POLLRDNORM;
> +
> +	if (sock_writeable(sk) ||
> +		(!test_and_set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags) &&
> +			 sock_writeable(sk)))
> +		mask |= POLLOUT | POLLWRNORM;
> +
> +	if (mp->dev->reg_state != NETREG_REGISTERED)
> +		mask = POLLERR;
> +
> +	mp_put(mfile);
> +	return mask;
> +}
> +
> +static ssize_t mp_chr_aio_write(struct kiocb *iocb, const struct iovec *iov,
> +				unsigned long count, loff_t pos)
> +{
> +	struct file *file = iocb->ki_filp;
> +	struct mp_struct *mp = mp_get(file->private_data);
> +	struct sock *sk = mp->socket.sk;
> +	struct sk_buff *skb;
> +	int len, err;
> +	ssize_t result = 0;
> +
> +	if (!mp)
> +		return -EBADFD;
> +
> +	/* currently, async is not supported.
> +	 * but we may support real async aio from user application,
> +	 * maybe qemu virtio-net backend.
> +	 */
> +	if (!is_sync_kiocb(iocb))
> +		return -EFAULT;
> +
> +	len = iov_length(iov, count);
> +
> +	if (unlikely(len < ETH_HLEN))
> +		return -EINVAL;
> +
> +	skb = sock_alloc_send_skb(sk, len + NET_IP_ALIGN,
> +				  file->f_flags & O_NONBLOCK, &err);
> +
> +	if (!skb)
> +		return -ENOMEM;
> +
> +	skb_reserve(skb, NET_IP_ALIGN);
> +	skb_put(skb, len);
> +
> +	if (skb_copy_datagram_from_iovec(skb, 0, iov, 0, len)) {
> +		kfree_skb(skb);
> +		return -EAGAIN;
> +	}
> +
> +	skb->protocol = eth_type_trans(skb, mp->dev);
> +	skb->dev = mp->dev;
> +
> +	dev_queue_xmit(skb);
> +
> +	mp_put(file->private_data);
> +	return result;
> +}
> +
> +static int mp_chr_close(struct inode *inode, struct file *file)
> +{
> +	struct mp_file *mfile = file->private_data;
> +
> +	/*
> +	 * Ignore return value since an error only means there was nothing to
> +	 * do
> +	 */
> +	do_unbind(mfile);
> +
> +	put_net(mfile->net);
> +	kfree(mfile);
> +
> +	return 0;
> +}
> +
> +#ifdef CONFIG_COMPAT
> +static long mp_chr_compat_ioctl(struct file *f, unsigned int ioctl,
> +				unsigned long arg)
> +{
> +	return mp_chr_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
> +}
> +#endif
> +
> +static const struct file_operations mp_fops = {
> +	.owner  = THIS_MODULE,
> +	.llseek = no_llseek,
> +	.write  = do_sync_write,
> +	.aio_write = mp_chr_aio_write,
> +	.poll   = mp_chr_poll,
> +	.unlocked_ioctl = mp_chr_ioctl,
> +#ifdef CONFIG_COMPAT
> +	.compat_ioctl = mp_chr_compat_ioctl,
> +#endif
> +	.open   = mp_chr_open,
> +	.release = mp_chr_close,
> +};
> +
> +static struct miscdevice mp_miscdev = {
> +	.minor = MISC_DYNAMIC_MINOR,
> +	.name = "mp",
> +	.nodename = "net/mp",
> +	.fops = &mp_fops,
> +};
> +
> +static int mp_device_event(struct notifier_block *unused,
> +		unsigned long event, void *ptr)
> +{
> +	struct net_device *dev = ptr;
> +	struct mp_port *port;
> +	struct mp_struct *mp = NULL;
> +	struct socket *sock = NULL;
> +	struct sock *sk;
> +
> +	port = dev->mp_port;
> +	if (port == NULL)
> +		return NOTIFY_DONE;
> +
> +	switch (event) {
> +	case NETDEV_UNREGISTER:
> +		sock = dev->mp_port->sock;
> +		mp = container_of(sock->sk, struct mp_sock, sk)->mp;
> +		do_unbind(mp->mfile);
> +		break;
> +	case NETDEV_CHANGE:
> +		sk = dev->mp_port->sock->sk;
> +		sk->sk_state_change(sk);
> +		break;
> +	}
> +	return NOTIFY_DONE;
> +}
> +
> +static struct notifier_block mp_notifier_block __read_mostly = {
> +	.notifier_call  = mp_device_event,
> +};
> +
> +static int mp_init(void)
> +{
> +	int err = 0;
> +
> +	ext_page_info_cache = kmem_cache_create("skb_page_info",
> +						sizeof(struct page_info),
> +						0, SLAB_HWCACHE_ALIGN, NULL);
> +	if (!ext_page_info_cache)
> +		return -ENOMEM;
> +
> +	err = misc_register(&mp_miscdev);
> +	if (err) {
> +		printk(KERN_ERR "mp: Can't register misc device\n");
> +		kmem_cache_destroy(ext_page_info_cache);
> +	} else {
> +		printk(KERN_INFO "Registering mp misc device - minor = %d\n",
> +				mp_miscdev.minor);
> +		register_netdevice_notifier(&mp_notifier_block);
> +	}
> +	return err;
> +}
> +
> +void mp_exit(void)
> +{
> +	unregister_netdevice_notifier(&mp_notifier_block);
> +	misc_deregister(&mp_miscdev);
> +	kmem_cache_destroy(ext_page_info_cache);
> +}
> +
> +/* Get an underlying socket object from mp file.  Returns error unless file is
> + * attached to a device.  The returned object works like a packet socket, it
> + * can be used for sock_sendmsg/sock_recvmsg.  The caller is responsible for
> + * holding a reference to the file for as long as the socket is in use. */
> +struct socket *mp_get_socket(struct file *file)
> +{
> +	struct mp_file *mfile = file->private_data;
> +	struct mp_struct *mp;
> +
> +	if (file->f_op != &mp_fops)
> +		return ERR_PTR(-EINVAL);
> +	mp = mp_get(mfile);
> +	if (!mp)
> +		return ERR_PTR(-EBADFD);
> +	mp_put(mfile);
> +	return &mp->socket;
> +}
> +EXPORT_SYMBOL_GPL(mp_get_socket);
> +
> +module_init(mp_init);
> +module_exit(mp_exit);
> +MODULE_AUTHOR(DRV_COPYRIGHT);
> +MODULE_DESCRIPTION(DRV_DESCRIPTION);
> +MODULE_LICENSE("GPL v2");
> -- 
> 1.7.3
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/