[deliverable/linux.git] / arch / um / drivers / vde_user.c

/*
 * Copyright (C) 2007 Luca Bigliardi (shammash@artha.org).
 * Licensed under the GPL.
 */

#include <stddef.h>
#include <errno.h>
#include <libvdeplug.h>
#include "kern_constants.h"
#include "net_user.h"
#include "um_malloc.h"
#include "user.h"
#include "vde.h"

static int vde_user_init(void *data, void *dev)
{
	struct vde_data *pri = data;
	VDECONN *conn = NULL;
	int err = -EINVAL;

	pri->dev = dev;

	conn = vde_open(pri->vde_switch, pri->descr, pri->args);

	if (conn == NULL) {
		err = -errno;
		printk(UM_KERN_ERR "vde_user_init: vde_open failed, "
		       "errno = %d\n", errno);
		return err;
	}

	printk(UM_KERN_INFO "vde backend - connection opened\n");

	pri->conn = conn;

	return 0;
}

static int vde_user_open(void *data)
{
	struct vde_data *pri = data;

	if (pri->conn != NULL)
		return vde_datafd(pri->conn);

	printk(UM_KERN_WARNING "vde_open - we have no VDECONN to open");
	return -EINVAL;
}

static void vde_remove(void *data)
{
	struct vde_data *pri = data;

	if (pri->conn != NULL) {
		printk(UM_KERN_INFO "vde backend - closing connection\n");
		vde_close(pri->conn);
		pri->conn = NULL;
		kfree(pri->args);
		pri->args = NULL;
		return;
	}

	printk(UM_KERN_WARNING "vde_remove - we have no VDECONN to remove");
}

const struct net_user_info vde_user_info = {
	.init		= vde_user_init,
	.open		= vde_user_open,
	.close	 	= NULL,
	.remove	 	= vde_remove,
	.add_address	= NULL,
	.delete_address = NULL,
	.mtu		= ETH_MAX_PACKET,
	.max_packet	= ETH_MAX_PACKET + ETH_HEADER_OTHER,
};

void vde_init_libstuff(struct vde_data *vpri, struct vde_init *init)
{
	struct vde_open_args *args;

	vpri->args = uml_kmalloc(sizeof(struct vde_open_args), UM_GFP_KERNEL);
	if (vpri->args == NULL) {
		printk(UM_KERN_ERR "vde_init_libstuff - vde_open_args "
		       "allocation failed");
		return;
	}

	args = vpri->args;

	args->port = init->port;
	args->group = init->group;
	args->mode = init->mode ? init->mode : 0700;

	args->port ?  printk("port %d", args->port) :
		printk("undefined port");
}

int vde_user_read(void *conn, void *buf, int len)
{
	VDECONN *vconn = conn;
	int rv;

	if (vconn == NULL)
		return 0;

	rv = vde_recv(vconn, buf, len, 0);
	if (rv < 0) {
		if (errno == EAGAIN)
			return 0;
		return -errno;
	}
	else if (rv == 0)
		return -ENOTCONN;

	return rv;
}

int vde_user_write(void *conn, void *buf, int len)
{
	VDECONN *vconn = conn;

	if (vconn == NULL)
		return 0;

	return vde_send(vconn, buf, len, 0);
}
Commit	Line	Data
ad43c356 JD	1	/*
	2	* Copyright (C) 2007 Luca Bigliardi (shammash@artha.org).
	3	* Licensed under the GPL.
	4	*/
	5
cd1ae0e4	6	#include <stddef.h>
ad43c356	7	#include <errno.h>
ad43c356	8	#include <libvdeplug.h>
ad43c356	9	#include "kern_constants.h"
cd1ae0e4	10	#include "net_user.h"
ad43c356	11	#include "um_malloc.h"
cd1ae0e4	12	#include "user.h"
ad43c356 JD	13	#include "vde.h"
ad43c356 JD	14
ad43c356 JD	15	static int vde_user_init(void data, void dev)
	16	{
	17	struct vde_data *pri = data;
	18	VDECONN *conn = NULL;
	19	int err = -EINVAL;
	20
	21	pri->dev = dev;
	22
	23	conn = vde_open(pri->vde_switch, pri->descr, pri->args);
	24
	25	if (conn == NULL) {
	26	err = -errno;
	27	printk(UM_KERN_ERR "vde_user_init: vde_open failed, "
	28	"errno = %d\n", errno);
	29	return err;
	30	}
	31
	32	printk(UM_KERN_INFO "vde backend - connection opened\n");
	33
	34	pri->conn = conn;
	35
	36	return 0;
	37	}
	38
	39	static int vde_user_open(void *data)
	40	{
	41	struct vde_data *pri = data;
	42
	43	if (pri->conn != NULL)
	44	return vde_datafd(pri->conn);
	45
	46	printk(UM_KERN_WARNING "vde_open - we have no VDECONN to open");
	47	return -EINVAL;
	48	}
	49
	50	static void vde_remove(void *data)
	51	{
	52	struct vde_data *pri = data;
	53
	54	if (pri->conn != NULL) {
	55	printk(UM_KERN_INFO "vde backend - closing connection\n");
	56	vde_close(pri->conn);
	57	pri->conn = NULL;
	58	kfree(pri->args);
	59	pri->args = NULL;
	60	return;
	61	}
	62
	63	printk(UM_KERN_WARNING "vde_remove - we have no VDECONN to remove");
	64	}
	65
ad43c356 JD	66	const struct net_user_info vde_user_info = {
	67	.init = vde_user_init,
	68	.open = vde_user_open,
	69	.close = NULL,
	70	.remove = vde_remove,
ad43c356 JD	71	.add_address = NULL,
ad43c356 JD	72	.delete_address = NULL,
b53f35a8 JD	73	.mtu = ETH_MAX_PACKET,
b53f35a8 JD	74	.max_packet = ETH_MAX_PACKET + ETH_HEADER_OTHER,
ad43c356 JD	75	};
	76
	77	void vde_init_libstuff(struct vde_data vpri, struct vde_init init)
	78	{
	79	struct vde_open_args *args;
	80
41a9e64c	81	vpri->args = uml_kmalloc(sizeof(struct vde_open_args), UM_GFP_KERNEL);
ad43c356	82	if (vpri->args == NULL) {
b7c000cb	83	printk(UM_KERN_ERR "vde_init_libstuff - vde_open_args "
ad43c356 JD	84	"allocation failed");
	85	return;
	86	}
	87
	88	args = vpri->args;
	89
	90	args->port = init->port;
	91	args->group = init->group;
	92	args->mode = init->mode ? init->mode : 0700;
	93
41a9e64c LB	94	args->port ? printk("port %d", args->port) :
41a9e64c LB	95	printk("undefined port");
ad43c356 JD	96	}
	97
	98	int vde_user_read(void conn, void buf, int len)
	99	{
	100	VDECONN *vconn = conn;
	101	int rv;
	102
	103	if (vconn == NULL)
	104	return 0;
	105
	106	rv = vde_recv(vconn, buf, len, 0);
	107	if (rv < 0) {
	108	if (errno == EAGAIN)
	109	return 0;
	110	return -errno;
	111	}
	112	else if (rv == 0)
	113	return -ENOTCONN;
	114
	115	return rv;
	116	}
	117
	118	int vde_user_write(void conn, void buf, int len)
	119	{
	120	VDECONN *vconn = conn;
	121
	122	if (vconn == NULL)
	123	return 0;
	124
	125	return vde_send(vconn, buf, len, 0);
	126	}
	127