kudptest.c

实现一个网卡到内存空间的零拷贝程序

/*
 *  kudptest.c
 *  Joris van Rantwijk, May 2001.
 *
 *  Linux kernel mode UDP performance test.
 *
 *  Parameters:
 *    ipaddr="127.0.0.1"	Destination IP address.
 *    port=9			Destination port number.
 *    bufsize=16384		Buffer size in bytes.
 *    count=1			Number of buffers to send.
 */

#define __KERNEL__
#define MODULE
#define __KERNEL_SYSCALLS__

#include <linux/stddef.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/malloc.h>
#include <asm/uaccess.h>
#include <linux/net.h>
#include <linux/inet.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/fcntl.h>
#include <net/sock.h>

#define MODNAME		"kudptest"


MODULE_AUTHOR("Joris van Rantwijk");
MODULE_DESCRIPTION("Kernel mode UDP performance test");
MODULE_PARM(ipaddr, "s");
MODULE_PARM(port, "i");
MODULE_PARM(bufsize, "i");
MODULE_PARM(count, "i");


static int port = 9;
static const char * ipaddr = "127.0.0.1";
static int bufsize = 16384;
static int count = 1;


static int sendsocket(struct socket *sock, void *buf, size_t len,
                      unsigned flags, struct sockaddr *addr, int addr_len)
{
	struct msghdr msg;
	struct iovec iov;

	iov.iov_base = buf;
	iov.iov_len = len;
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = NULL;
	msg.msg_controllen = 0;
	msg.msg_name = addr;
	msg.msg_namelen = addr_len;
	msg.msg_flags = flags;

	return sock_sendmsg(sock, &msg, len);
}


static void performance_test(void)
{
	mm_segment_t oldfs;
	struct socket *sock;
	struct sockaddr_in saddr;
	struct timeval tv_start, tv_done;
	char *buf;
	int i, err, transmitted;
	int secs, usecs, msecs;

	/* Allocate data buffer */
	buf = kmalloc(bufsize, GFP_KERNEL);
	if (buf == NULL) {
		printk(MODNAME ": Cannot allocate buffer.\n");
		return;
	}

	/* Open datagram socket */
	err = sock_create(PF_INET, SOCK_DGRAM, 0, &sock);
	if (err < 0) {
		printk(MODNAME ": Cannot create socket (%d).\n", err);
		kfree(buf);
		return;
	}

	/* Fill in socket address structure */
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);
	saddr.sin_addr.s_addr = in_aton(ipaddr);

	printk(MODNAME ": Ready for transmission.\n");

	/* Data buffer is in kernel memory, not user memory */
	oldfs = get_fs();
	set_fs(KERNEL_DS);

	do_gettimeofday(&tv_start);

	/* Do transmission */
	transmitted = 0;
	for (i = 0; i < count; i++) {
		err = sendsocket(sock, buf, bufsize, 0,
		                 (struct sockaddr *) &saddr, sizeof(saddr));
		if (err != bufsize) {
			printk(MODNAME ": sendsocket returned %d.\n", err);
			break;
		}
		transmitted += err;
	}

		printk(MODNAME ": wmem_alloc=%d sndbuf=%d\n", atomic_read(&sock->sk->wmem_alloc), sock->sk->sndbuf);
	do_gettimeofday(&tv_done);

	/* Calculate elapsed time */
	secs = tv_done.tv_sec - tv_start.tv_sec;
	usecs = tv_done.tv_usec - tv_start.tv_usec;
	if (usecs < 0) { secs--; usecs += 1000000; }
	msecs = secs * 1000 + usecs / 1000;
	if (msecs == 0) msecs = 1;

	set_fs(oldfs);

	printk(MODNAME ": transmitted %d bytes in %d.%03d sec -> %d kB/s.\n",
	       transmitted, secs, usecs / 1000, transmitted / msecs);

	printk(MODNAME ": Done.\n");

	/* Close socket, free buffer */
	sock_release(sock);
	kfree(buf);
}


int init_module(void)
{
	printk(MODNAME ": Entering init_module.\n");
	printk(MODNAME ": ipaddr=%s port=%d bufsize=%d count=%d\n",
	       ipaddr, port, bufsize, count);

	performance_test();

	printk(MODNAME ": Returning from init_module with EBUSY.\n");
	return -EBUSY;
}


int cleanup_module(void)
{
	printk(MODNAME ": cleanup_module\n");
	return 0;
}

/* end */