slirp.c File Reference

Linux Slirp network driver. More...

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/in.h>
#include <ipxe/timer.h>
#include <ipxe/retry.h>
#include <ipxe/linux.h>
#include <ipxe/linux_api.h>
#include <ipxe/slirp.h>

Go to the source code of this file.

Data Structures
struct	slirp_nic
	A Slirp network interface. More...
struct	slirp_alarm
	A Slirp alarm timer. More...

Macros
#define	SLIRP_MAX_FDS   128
	Maximum number of open file descriptors.

Functions
static ssize_t __asmcall	slirp_send_packet (const void *buf, size_t len, void *device)
	Send packet.
static void __asmcall	slirp_guest_error (const char *msg, void *device)
	Print an error message.
static int64_t __asmcall	slirp_clock_get_ns (void *device __unused)
	Get virtual clock.
static void	slirp_expired (struct retry_timer *timer, int over __unused)
	Handle timer expiry.
static void *__asmcall	slirp_timer_new (void(__asmcall *callback)(void *opaque), void *opaque, void *device)
	Create a new timer.
static void __asmcall	slirp_timer_free (void *timer, void *device)
	Delete a timer.
static void __asmcall	slirp_timer_mod (void *timer, int64_t expire, void *device)
	Set timer expiry time.
static void __asmcall	slirp_register_poll_fd (int fd, void *device)
	Register file descriptor for polling.
static void __asmcall	slirp_unregister_poll_fd (int fd, void *device)
	Unregister file descriptor.
static void __asmcall	slirp_notify (void *device)
	Notify that new events are ready.
static int	slirp_open (struct net_device *netdev)
	Open network device.
static void	slirp_close (struct net_device *netdev)
	Close network device.
static int	slirp_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit packet.
static int __asmcall	slirp_add_poll (int fd, int events, void *device)
	Add polling file descriptor.
static int __asmcall	slirp_get_revents (int index, void *device)
	Get returned events for a file descriptor.
static void	slirp_poll (struct net_device *netdev)
	Poll for completed and received packets.
static int	slirp_probe (struct linux_device *linux, struct linux_device_request *request)
	Probe device.
static void	slirp_remove (struct linux_device *linux)
	Remove device.
	LINUX_ROM ("slirp", "libslirp NIC")

Variables
static const uint8_t	slirp_default_mac [ETH_ALEN]
	Default MAC address.
static struct slirp_callbacks	slirp_callbacks
	Slirp callbacks.
static struct net_device_operations	slirp_operations
	Network device operations.
struct linux_driver slirp_driver	__linux_driver
	Slirp driver.

Detailed Description

Linux Slirp network driver.

Definition in file slirp.c.

Macro Definition Documentation

SLIRP_MAX_FDS

#define SLIRP_MAX_FDS   128

Maximum number of open file descriptors.

Definition at line 40 of file slirp.c.

Referenced by slirp_add_poll().

Function Documentation

slirp_send_packet()

ssize_t __asmcall slirp_send_packet ( const void * buf, size_t len, void * device )

static

Send packet.

Parameters

buf	Data buffer
len	Length of data
device	Device opaque pointer

Return values

len	Consumed length (or negative on error)

Definition at line 83 of file slirp.c.

                                                            {
        struct net_device *netdev = device;
        struct io_buffer *iobuf;
 
        /* Allocate I/O buffer */
        iobuf = alloc_iob ( len );
        if ( ! iobuf )
                return -1;
 
        /* Populate I/O buffer */
        memcpy ( iob_put ( iobuf, len ), buf, len );
 
        /* Hand off to network stack */
        netdev_rx ( netdev, iobuf );
 
        return len;
}

References __asmcall, alloc_iob(), iob_put, len, memcpy(), netdev, and netdev_rx().

slirp_guest_error()

void __asmcall slirp_guest_error ( const char * msg, void * device )

static

Print an error message.

Parameters

msg	Error message
device	Device opaque pointer

Definition at line 108 of file slirp.c.

                                                                          {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
 
        DBGC ( slirp, "SLIRP %p error: %s\n", slirp, msg );
}

References __asmcall, DBGC, msg(), netdev, and slirp_nic::slirp.

slirp_clock_get_ns()

int64_t __asmcall slirp_clock_get_ns ( void *device __unused )

static

Get virtual clock.

Parameters

device

Device opaque pointer

Return values

clock_ns

Clock time in nanoseconds

Definition at line 121 of file slirp.c.

                                                                      {
        int64_t time;
 
        time = currticks();
        return ( time * ( 1000000 / TICKS_PER_MS ) );
}

References __asmcall, __unused, currticks(), and TICKS_PER_MS.

slirp_expired()

void slirp_expired ( struct retry_timer * timer, int over __unused )

static

Handle timer expiry.

Parameters

timer	Retry timer
over	Failure indicator

Definition at line 134 of file slirp.c.

                                                                           {
        struct slirp_alarm *alarm =
                container_of ( timer, struct slirp_alarm, timer );
        struct slirp_nic *slirp = alarm->slirp;
 
        /* Notify callback */
        DBGC ( slirp, "SLIRP %p timer fired\n", slirp );
        alarm->callback ( alarm->opaque );
}

References __unused, container_of, DBGC, slirp_alarm::opaque, slirp_alarm::slirp, and slirp_nic::slirp.

Referenced by slirp_timer_new().

slirp_timer_new()

void *__asmcall slirp_timer_new ( void(__asmcall *callback)(void *opaque) , void * opaque, void * device )

static

Create a new timer.

Parameters

callback	Timer callback
opaque	Timer opaque pointer
device	Device opaque pointer

Return values

timer

Timer

Definition at line 153 of file slirp.c.

                                               {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
        struct slirp_alarm *alarm;
 
        /* Allocate timer */
        alarm = malloc ( sizeof ( *alarm ) );
        if ( ! alarm ) {
                DBGC ( slirp, "SLIRP %p could not allocate timer\n", slirp );
                return NULL;
        }
 
        /* Initialise timer */
        memset ( alarm, 0, sizeof ( *alarm ) );
        alarm->slirp = slirp;
        timer_init ( &alarm->timer, slirp_expired, NULL );
        alarm->callback = callback;
        alarm->opaque = opaque;
        DBGC ( slirp, "SLIRP %p timer %p has callback %p (%p)\n",
               slirp, alarm, alarm->callback, alarm->opaque );
 
        return alarm;
}

References __asmcall, DBGC, malloc(), memset(), netdev, NULL, slirp_alarm::opaque, slirp_alarm::slirp, slirp_nic::slirp, slirp_expired(), and slirp_alarm::timer.

slirp_timer_free()

void __asmcall slirp_timer_free ( void * timer, void * device )

static

Delete a timer.

Parameters

timer	Timer
device	Device opaque pointer

Definition at line 184 of file slirp.c.

                                                                     {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
        struct slirp_alarm *alarm = timer;
 
        /* Ignore timers that failed to allocate */
        if ( ! alarm )
                return;
 
        /* Stop timer */
        stop_timer ( &alarm->timer );
 
        /* Free timer */
        free ( alarm );
        DBGC ( slirp, "SLIRP %p timer %p freed\n", slirp, alarm );
}

References __asmcall, DBGC, free, netdev, slirp_alarm::slirp, slirp_nic::slirp, stop_timer(), and slirp_alarm::timer.

slirp_timer_mod()

void __asmcall slirp_timer_mod ( void * timer, int64_t expire, void * device )

static

Set timer expiry time.

Parameters

timer	Timer
expire	Expiry time
device	Device opaque pointer

Definition at line 208 of file slirp.c.

                                                       {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
        struct slirp_alarm *alarm = timer;
        int64_t timeout_ms;
        unsigned long timeout;
 
        /* Ignore timers that failed to allocate */
        if ( ! alarm )
                return;
 
        /* (Re)start timer */
        timeout_ms = ( expire - ( currticks() / TICKS_PER_MS ) );
        if ( timeout_ms < 0 )
                timeout_ms = 0;
        timeout = ( timeout_ms * TICKS_PER_MS );
        start_timer_fixed ( &alarm->timer, timeout );
        DBGC ( slirp, "SLIRP %p timer %p set for %ld ticks\n",
               slirp, alarm, timeout );
}

References __asmcall, currticks(), DBGC, netdev, slirp_alarm::slirp, slirp_nic::slirp, start_timer_fixed(), TICKS_PER_MS, timeout(), and slirp_alarm::timer.

slirp_register_poll_fd()

void __asmcall slirp_register_poll_fd ( int fd, void * device )

static

Register file descriptor for polling.

Parameters

fd	File descriptor
device	Device opaque pointer

Definition at line 236 of file slirp.c.

                                                                      {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
 
        DBGC ( slirp, "SLIRP %p registered FD %d\n", slirp, fd );
}

References __asmcall, DBGC, netdev, and slirp_nic::slirp.

slirp_unregister_poll_fd()

void __asmcall slirp_unregister_poll_fd ( int fd, void * device )

static

Unregister file descriptor.

Parameters

fd	File descriptor
device	Device opaque pointer

Definition at line 249 of file slirp.c.

                                                                        {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
 
        DBGC ( slirp, "SLIRP %p unregistered FD %d\n", slirp, fd );
}

References __asmcall, DBGC, netdev, and slirp_nic::slirp.

slirp_notify()

void __asmcall slirp_notify ( void * device )

static

Notify that new events are ready.

Parameters

device

Device opaque pointer

Definition at line 261 of file slirp.c.

                                                    {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
 
        DBGC2 ( slirp, "SLIRP %p notified\n", slirp );
}

References __asmcall, DBGC2, netdev, and slirp_nic::slirp.

slirp_open()

int slirp_open ( struct net_device * netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 294 of file slirp.c.

                                                    {
        struct slirp_nic *slirp = netdev->priv;
 
        /* Nothing to do */
        DBGC ( slirp, "SLIRP %p opened\n", slirp );
 
        return 0;
}

References DBGC, netdev, and slirp_nic::slirp.

slirp_close()

void slirp_close ( struct net_device * netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 308 of file slirp.c.

                                                      {
        struct slirp_nic *slirp = netdev->priv;
 
        /* Nothing to do */
        DBGC ( slirp, "SLIRP %p closed\n", slirp );
}

References DBGC, netdev, and slirp_nic::slirp.

slirp_transmit()

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

static

Transmit packet.

Parameters

netdev	Network device
iobuf	I/O buffer

Return values

rc	Return status code

Definition at line 322 of file slirp.c.

                                                      {
        struct slirp_nic *slirp = netdev->priv;
 
        /* Transmit packet */
        linux_slirp_input ( slirp->slirp, iobuf->data, iob_len ( iobuf ) );
        netdev_tx_complete ( netdev, iobuf );
 
        return 0;
}

References io_buffer::data, iob_len(), linux_slirp_input(), netdev, netdev_tx_complete(), and slirp_nic::slirp.

slirp_add_poll()

int __asmcall slirp_add_poll ( int fd, int events, void * device )

static

Add polling file descriptor.

Parameters

fd	File descriptor
events	Events of interest
device	Device opaque pointer

Return values

index

File descriptor index

Definition at line 341 of file slirp.c.

                                                                         {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
        struct pollfd *pollfd;
        unsigned int index;
 
        /* Fail if too many descriptors are registered */
        if ( slirp->numfds >= SLIRP_MAX_FDS ) {
                DBGC ( slirp, "SLIRP %p too many file descriptors\n", slirp );
                return -1;
        }
 
        /* Populate polling file descriptor */
        index = slirp->numfds++;
        pollfd = &slirp->pollfds[index];
        pollfd->fd = fd;
        pollfd->events = 0;
        if ( events & SLIRP_EVENT_IN )
                pollfd->events |= POLLIN;
        if ( events & SLIRP_EVENT_OUT )
                pollfd->events |= POLLOUT;
        if ( events & SLIRP_EVENT_PRI )
                pollfd->events |= POLLPRI;
        if ( events & SLIRP_EVENT_ERR )
                pollfd->events |= POLLERR;
        if ( events & SLIRP_EVENT_HUP )
                pollfd->events |= ( POLLHUP | POLLRDHUP );
        DBGCP ( slirp, "SLIRP %p polling FD %d event mask %#04x(%#04x)\n",
                slirp, fd, events, pollfd->events );
 
        return index;
}

References __asmcall, DBGC, DBGCP, index, netdev, slirp_nic::numfds, slirp_nic::pollfds, slirp_nic::slirp, SLIRP_EVENT_ERR, SLIRP_EVENT_HUP, SLIRP_EVENT_IN, SLIRP_EVENT_OUT, SLIRP_EVENT_PRI, and SLIRP_MAX_FDS.

Referenced by slirp_poll().

slirp_get_revents()

int __asmcall slirp_get_revents ( int index, void * device )

static

Get returned events for a file descriptor.

Parameters

index	File descriptor index
device	Device opaque pointer

Return values

events

Returned events

Definition at line 381 of file slirp.c.

                                                                   {
        struct net_device *netdev = device;
        struct slirp_nic *slirp = netdev->priv;
        int revents;
        int events;
 
        /* Ignore failed descriptors */
        if ( index < 0 )
                return 0;
 
        /* Collect events */
        revents = slirp->pollfds[index].revents;
        events = 0;
        if ( revents & POLLIN )
                events |= SLIRP_EVENT_IN;
        if ( revents & POLLOUT )
                events |= SLIRP_EVENT_OUT;
        if ( revents & POLLPRI )
                events |= SLIRP_EVENT_PRI;
        if ( revents & POLLERR )
                events |= SLIRP_EVENT_ERR;
        if ( revents & ( POLLHUP | POLLRDHUP ) )
                events |= SLIRP_EVENT_HUP;
        if ( events ) {
                DBGC2 ( slirp, "SLIRP %p polled FD %d events %#04x(%#04x)\n",
                        slirp, slirp->pollfds[index].fd, events, revents );
        }
 
        return events;
}

References __asmcall, DBGC2, index, netdev, slirp_nic::slirp, SLIRP_EVENT_ERR, SLIRP_EVENT_HUP, SLIRP_EVENT_IN, SLIRP_EVENT_OUT, and SLIRP_EVENT_PRI.

Referenced by slirp_poll().

slirp_poll()

void slirp_poll ( struct net_device * netdev )

static

Poll for completed and received packets.

Parameters

netdev

Network device

Definition at line 417 of file slirp.c.

                                                     {
        struct slirp_nic *slirp = netdev->priv;
        uint32_t timeout = 0;
        int ready;
        int error;
 
        /* Rebuild polling file descriptor list */
        slirp->numfds = 0;
        linux_slirp_pollfds_fill ( slirp->slirp, &timeout,
                                   slirp_add_poll, netdev );
 
        /* Poll descriptors */
        ready = linux_poll ( slirp->pollfds, slirp->numfds, 0 );
        error = ( ready == -1 );
        linux_slirp_pollfds_poll ( slirp->slirp, error, slirp_get_revents,
                                   netdev );
 
        /* Record polling errors */
        if ( error ) {
                DBGC ( slirp, "SLIRP %p poll failed: %s\n",
                       slirp, linux_strerror ( linux_errno ) );
                netdev_rx_err ( netdev, NULL, -ELINUX ( linux_errno ) );
        }
}

References DBGC, ELINUX, error, linux_errno, linux_poll(), linux_slirp_pollfds_fill(), linux_slirp_pollfds_poll(), linux_strerror(), netdev, netdev_rx_err(), NULL, slirp_nic::slirp, slirp_add_poll(), slirp_get_revents(), and timeout().

slirp_probe()

int slirp_probe ( struct linux_device * linux, struct linux_device_request * request )

static

Probe device.

Parameters

linux	Linux device
request	Device creation request

Return values

rc	Return status code

Definition at line 464 of file slirp.c.

                                                                {
        struct net_device *netdev;
        struct slirp_nic *slirp;
        struct slirp_config config;
        int rc;
 
        /* Allocate device */
        netdev = alloc_etherdev ( sizeof ( *slirp ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &slirp_operations );
        linux_set_drvdata ( linux, netdev );
        snprintf ( linux->dev.name, sizeof ( linux->dev.name ), "host" );
        netdev->dev = &linux->dev;
        memcpy ( netdev->hw_addr, slirp_default_mac, ETH_ALEN );
        slirp = netdev->priv;
        memset ( slirp, 0, sizeof ( *slirp ) );
 
        /* Apply requested settings */
        linux_apply_settings ( &request->settings,
                               netdev_settings ( netdev ) );
 
        /* Initialise default configuration (matching qemu) */
        memset ( &config, 0, sizeof ( config ) );
        config.version = 1;
        config.in_enabled = true;
        config.vnetwork.s_addr = htonl ( 0x0a000200 ); /* 10.0.2.0 */
        config.vnetmask.s_addr = htonl ( 0xffffff00 ); /* 255.255.255.0 */
        config.vhost.s_addr = htonl ( 0x0a000202 ); /* 10.0.2.2 */
        config.in6_enabled = true;
        config.vdhcp_start.s_addr = htonl ( 0x0a00020f ); /* 10.0.2.15 */
        config.vnameserver.s_addr = htonl ( 0x0a000203 ); /* 10.0.2.3 */
 
        /* Instantiate device */
        slirp->slirp = linux_slirp_new ( &config, &slirp_callbacks, netdev );
        if ( ! slirp->slirp ) {
                DBGC ( slirp, "SLIRP could not instantiate\n" );
                rc = -ENODEV;
                goto err_new;
        }
 
        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register;
 
        /* Set link up since there is no concept of link state */
        netdev_link_up ( netdev );
 
        return 0;
 
        unregister_netdev ( netdev );
 err_register:
        linux_slirp_cleanup ( slirp->slirp );
 err_new:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References alloc_etherdev(), DBGC, linux_device::dev, ENODEV, ENOMEM, ETH_ALEN, htonl, slirp_config::in6_enabled, slirp_config::in_enabled, linux_apply_settings(), linux_set_drvdata(), linux_slirp_cleanup(), linux_slirp_new(), memcpy(), memset(), device::name, netdev, netdev_init(), netdev_link_up(), netdev_nullify(), netdev_put(), netdev_settings(), rc, register_netdev(), request, in_addr::s_addr, slirp_nic::slirp, slirp_default_mac, slirp_operations, snprintf(), unregister_netdev(), slirp_config::vdhcp_start, slirp_config::version, slirp_config::vhost, slirp_config::vnameserver, slirp_config::vnetmask, and slirp_config::vnetwork.

slirp_remove()

void slirp_remove ( struct linux_device * linux )

static

Remove device.

Parameters

linux

Linux device

Definition at line 532 of file slirp.c.

                                                        {
        struct net_device *netdev = linux_get_drvdata ( linux );
        struct slirp_nic *slirp = netdev->priv;
 
        /* Unregister network device */
        unregister_netdev ( netdev );
 
        /* Shut down device */
        linux_slirp_cleanup ( slirp->slirp );
 
        /* Free network device */
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References linux_get_drvdata(), linux_slirp_cleanup(), netdev, netdev_nullify(), netdev_put(), slirp_nic::slirp, and unregister_netdev().

LINUX_ROM()

LINUX_ROM	(	"slirp"	,
		"libslirp NIC"	)

Variable Documentation

slirp_default_mac

const uint8_t slirp_default_mac[ETH_ALEN]

static

Initial value:

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

Default MAC address.

Definition at line 65 of file slirp.c.

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

Referenced by slirp_probe().

slirp_callbacks

struct slirp_callbacks slirp_callbacks

static

Initial value:

= {
        .send_packet            = slirp_send_packet,
        .guest_error            = slirp_guest_error,
        .clock_get_ns           = slirp_clock_get_ns,
        .timer_new              = slirp_timer_new,
        .timer_free             = slirp_timer_free,
        .timer_mod              = slirp_timer_mod,
        .register_poll_fd       = slirp_register_poll_fd,
        .unregister_poll_fd     = slirp_unregister_poll_fd,
        .notify                 = slirp_notify,
}

Slirp callbacks.

Definition at line 269 of file slirp.c.

                                                {
        .send_packet            = slirp_send_packet,
        .guest_error            = slirp_guest_error,
        .clock_get_ns           = slirp_clock_get_ns,
        .timer_new              = slirp_timer_new,
        .timer_free             = slirp_timer_free,
        .timer_mod              = slirp_timer_mod,
        .register_poll_fd       = slirp_register_poll_fd,
        .unregister_poll_fd     = slirp_unregister_poll_fd,
        .notify                 = slirp_notify,
};

slirp_operations

struct net_device_operations slirp_operations

static

Initial value:

= {
        .open           = slirp_open,
        .close          = slirp_close,
        .transmit       = slirp_transmit,
        .poll           = slirp_poll,
}

Network device operations.

Definition at line 443 of file slirp.c.

                                                       {
        .open           = slirp_open,
        .close          = slirp_close,
        .transmit       = slirp_transmit,
        .poll           = slirp_poll,
};

Referenced by slirp_probe().

__linux_driver

struct linux_driver slirp_driver __linux_driver

Initial value:

= {
        .name = "slirp",
        .probe = slirp_probe,
        .remove = slirp_remove,
}

Slirp driver.

Definition at line 548 of file slirp.c.

                                                  {
        .name = "slirp",
        .probe = slirp_probe,
        .remove = slirp_remove,
};