tap.c File Reference

The TAP driver. More...

#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <ipxe/linux_api.h>
#include <ipxe/list.h>
#include <ipxe/linux.h>
#include <ipxe/malloc.h>
#include <ipxe/device.h>
#include <ipxe/netdevice.h>
#include <ipxe/iobuf.h>
#include <ipxe/ethernet.h>
#include <ipxe/settings.h>
#include <ipxe/socket.h>
#include <linux/socket.h>
#include <linux/if.h>
#include <linux/if_ether.h>
#include <linux/if_tun.h>

Go to the source code of this file.

Data Structures
struct	tap_nic

Macros
#define	_SYS_SOCKET_H
#define	__GLIBC__   2
#define	RX_BUF_SIZE   1536
#define	RX_QUOTA   4

Functions
static int	tap_open (struct net_device *netdev)
	Open the TAP device.
static void	tap_close (struct net_device *netdev)
	Close the TAP device.
static int	tap_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit an ethernet packet.
static void	tap_poll (struct net_device *netdev)
	Poll for new packets.
static void	tap_irq (struct net_device *netdev, int enable)
	Set irq.
static int	tap_probe (struct linux_device *device, struct linux_device_request *request)
	Handle a device request for the tap driver.
static void	tap_remove (struct linux_device *device)
	Remove the device.
	LINUX_ROM ("tap", "Linux TUN/TAP NIC")

Variables
static const uint8_t	tap_default_mac [ETH_ALEN]
	Default MAC address.
static struct net_device_operations	tap_operations
	Tap operations.
struct linux_driver tap_driver	__linux_driver
	Tap linux_driver.

Detailed Description

The TAP driver.

The TAP is a Virtual Ethernet network device.

Definition in file tap.c.

Macro Definition Documentation

_SYS_SOCKET_H

#define _SYS_SOCKET_H

Definition at line 34 of file tap.c.

__GLIBC__

#define __GLIBC__   2

Definition at line 35 of file tap.c.

RX_BUF_SIZE

#define RX_BUF_SIZE   1536

Definition at line 42 of file tap.c.

RX_QUOTA

#define RX_QUOTA   4

Definition at line 43 of file tap.c.

Referenced by tap_poll().

Function Documentation

tap_open()

int tap_open ( struct net_device * netdev )

static

Open the TAP device.

Definition at line 64 of file tap.c.

{
        struct tap_nic * nic = netdev->priv;
        struct ifreq ifr;
        int ret;
 
        nic->fd = linux_open("/dev/net/tun", O_RDWR);
        if (nic->fd < 0) {
                DBGC(nic, "tap %p open('/dev/net/tun') = %d (%s)\n", nic, nic->fd, linux_strerror(linux_errno));
                return nic->fd;
        }
 
        memset(&ifr, 0, sizeof(ifr));
        /* IFF_NO_PI for no extra packet information */
        ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
        strncpy(ifr.ifr_name, nic->interface, IFNAMSIZ);
        DBGC(nic, "tap %p interface = '%s'\n", nic, nic->interface);
 
        ret = linux_ioctl(nic->fd, TUNSETIFF, &ifr);
 
        if (ret != 0) {
                DBGC(nic, "tap %p ioctl(%d, ...) = %d (%s)\n", nic, nic->fd, ret, linux_strerror(linux_errno));
                linux_close(nic->fd);
                return ret;
        }
 
        /* Set nonblocking mode to make tap_poll easier */
        ret = linux_fcntl(nic->fd, F_SETFL, O_NONBLOCK);
 
        if (ret != 0) {
                DBGC(nic, "tap %p fcntl(%d, ...) = %d (%s)\n", nic, nic->fd, ret, linux_strerror(linux_errno));
                linux_close(nic->fd);
                return ret;
        }
 
        return 0;
}

References DBGC, linux_close(), linux_errno, linux_fcntl(), linux_ioctl(), linux_open(), linux_strerror(), memset(), netdev, and strncpy().

tap_close()

void tap_close ( struct net_device * netdev )

static

Close the TAP device.

Definition at line 103 of file tap.c.

{
        struct tap_nic * nic = netdev->priv;
        linux_close(nic->fd);
}

References linux_close(), and netdev.

tap_transmit()

int tap_transmit ( struct net_device * netdev, struct io_buffer * iobuf )

static

Transmit an ethernet packet.

The packet can be written to the TAP device and marked as complete immediately.

Definition at line 114 of file tap.c.

{
        struct tap_nic * nic = netdev->priv;
        int rc;
 
        /* Pad and align packet */
        iob_pad(iobuf, ETH_ZLEN);
 
        rc = linux_write(nic->fd, iobuf->data, iobuf->tail - iobuf->data);
        DBGC2(nic, "tap %p wrote %d bytes\n", nic, rc);
        netdev_tx_complete(netdev, iobuf);
 
        return 0;
}

References io_buffer::data, DBGC2, ETH_ZLEN, iob_pad(), linux_write(), netdev, netdev_tx_complete(), rc, and io_buffer::tail.

tap_poll()

void tap_poll ( struct net_device * netdev )

static

Poll for new packets.

Definition at line 130 of file tap.c.

{
        struct tap_nic * nic = netdev->priv;
        struct pollfd pfd;
        struct io_buffer * iobuf;
        unsigned int quota = RX_QUOTA;
        int r;
 
        pfd.fd = nic->fd;
        pfd.events = POLLIN;
        if (linux_poll(&pfd, 1, 0) == -1) {
                DBGC(nic, "tap %p poll failed (%s)\n", nic, linux_strerror(linux_errno));
                return;
        }
        if ((pfd.revents & POLLIN) == 0)
                return;
 
        /* At this point we know there is at least one new packet to be read */
 
        iobuf = alloc_iob(RX_BUF_SIZE);
        if (! iobuf)
                goto allocfail;
 
        while (quota-- &&
               ((r = linux_read(nic->fd, iobuf->data, RX_BUF_SIZE)) > 0)) {
                DBGC2(nic, "tap %p read %d bytes\n", nic, r);
 
                iob_put(iobuf, r);
                netdev_rx(netdev, iobuf);
 
                iobuf = alloc_iob(RX_BUF_SIZE);
                if (! iobuf)
                        goto allocfail;
        }
 
        free_iob(iobuf);
        return;
 
allocfail:
        DBGC(nic, "tap %p alloc_iob failed\n", nic);
}

References alloc_iob(), io_buffer::data, DBGC, DBGC2, free_iob(), iob_put, linux_errno, linux_poll(), linux_read(), linux_strerror(), netdev, netdev_rx(), r, RX_BUF_SIZE, and RX_QUOTA.

tap_irq()

void tap_irq ( struct net_device * netdev, int enable )

static

Set irq.

Not used on linux, provide a dummy implementation.

Definition at line 177 of file tap.c.

{
        struct tap_nic *nic = netdev->priv;
 
        DBGC(nic, "tap %p irq enable = %d\n", nic, enable);
}

References DBGC, and netdev.

tap_probe()

int tap_probe ( struct linux_device * device, struct linux_device_request * request )

static

Handle a device request for the tap driver.

Definition at line 194 of file tap.c.

{
        struct linux_setting *if_setting;
        struct net_device *netdev;
        struct tap_nic *nic;
        int rc;
 
        netdev = alloc_etherdev(sizeof(*nic));
        if (! netdev)
                return -ENOMEM;
 
        netdev_init(netdev, &tap_operations);
        nic = netdev->priv;
        linux_set_drvdata(device, netdev);
        netdev->dev = &device->dev;
        memcpy ( netdev->hw_addr, tap_default_mac, ETH_ALEN );
        memset(nic, 0, sizeof(*nic));
 
        /* Look for the mandatory if setting */
        if_setting = linux_find_setting("if", &request->settings);
 
        /* No if setting */
        if (! if_setting) {
                printf("tap missing a mandatory if setting\n");
                rc = -EINVAL;
                goto err_settings;
        }
 
        nic->interface = if_setting->value;
        snprintf ( device->dev.name, sizeof ( device->dev.name ), "%s",
                   nic->interface );
        device->dev.desc.bus_type = BUS_TYPE_TAP;
        if_setting->applied = 1;
 
        /* Apply rest of the settings */
        linux_apply_settings(&request->settings, &netdev->settings.settings);
 
        /* Register network device */
        if ((rc = register_netdev(netdev)) != 0)
                goto err_register;
 
        netdev_link_up(netdev);
 
        return 0;
 
        unregister_netdev(netdev);
err_register:
err_settings:
        netdev_nullify(netdev);
        netdev_put(netdev);
        return rc;
}

References alloc_etherdev(), linux_setting::applied, device_description::bus_type, BUS_TYPE_TAP, device::desc, EINVAL, ENOMEM, ETH_ALEN, linux_apply_settings(), linux_find_setting(), linux_set_drvdata(), memcpy(), memset(), device::name, netdev, netdev_init(), netdev_link_up(), netdev_nullify(), netdev_put(), printf(), rc, register_netdev(), request, snprintf(), tap_default_mac, tap_operations, unregister_netdev(), and linux_setting::value.

tap_remove()

void tap_remove ( struct linux_device * device )

static

Remove the device.

Definition at line 248 of file tap.c.

{
        struct net_device *netdev = linux_get_drvdata(device);
        unregister_netdev(netdev);
        netdev_nullify(netdev);
        netdev_put(netdev);
}

References linux_get_drvdata(), netdev, netdev_nullify(), netdev_put(), and unregister_netdev().

LINUX_ROM()

LINUX_ROM	(	"tap"	,
		"Linux TUN/TAP NIC"	)

Variable Documentation

tap_default_mac

const uint8_t tap_default_mac[ETH_ALEN]

static

Initial value:

=
        { 0x52, 0x54, 0x00, 0x12, 0x34, 0x56 }

Default MAC address.

Definition at line 60 of file tap.c.

        { 0x52, 0x54, 0x00, 0x12, 0x34, 0x56 };

Referenced by tap_probe().

tap_operations

struct net_device_operations tap_operations

static

Initial value:

= {
        .open           = tap_open,
        .close          = tap_close,
        .transmit       = tap_transmit,
        .poll           = tap_poll,
        .irq            = tap_irq,
}

Tap operations.

Definition at line 185 of file tap.c.

                                                     {
        .open           = tap_open,
        .close          = tap_close,
        .transmit       = tap_transmit,
        .poll           = tap_poll,
        .irq            = tap_irq,
};

Referenced by tap_probe().

__linux_driver

struct linux_driver tap_driver __linux_driver

Initial value:

= {
        .name = "tap",
        .probe = tap_probe,
        .remove = tap_remove,
}

Tap linux_driver.

Definition at line 257 of file tap.c.

                                                {
        .name = "tap",
        .probe = tap_probe,
        .remove = tap_remove,
};