src/drivers/linux/slirp.c

/*
 * Copyright (C) 2021 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * 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 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#include <stdio.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>

/** @file
 *
 * Linux Slirp network driver
 *
 */

/** Maximum number of open file descriptors */
#define SLIRP_MAX_FDS 128

/** A Slirp network interface */
struct slirp_nic {
	/** The libslirp device object */
	struct Slirp *slirp;
	/** Polling file descriptor list */
	struct pollfd pollfds[SLIRP_MAX_FDS];
	/** Number of file descriptors */
	unsigned int numfds;
};

/** A Slirp alarm timer */
struct slirp_alarm {
	/** Slirp network interface */
	struct slirp_nic *slirp;
	/** Retry timer */
	struct retry_timer timer;
	/** Callback function */
	void ( __asmcall * callback ) ( void *opaque );
	/** Opaque value for callback function */
	void *opaque;
};

/** Default MAC address */
static const uint8_t slirp_default_mac[ETH_ALEN] =
	{ 0x52, 0x54, 0x00, 0x12, 0x34, 0x56 };

/******************************************************************************
 *
 * Slirp interface
 *
 ******************************************************************************
 */

/**
 * Send packet
 *
 * @v buf		Data buffer
 * @v len		Length of data
 * @v device		Device opaque pointer
 * @ret len		Consumed length (or negative on error)
 */
static ssize_t __asmcall slirp_send_packet ( const void *buf, size_t len,
					     void *device ) {
	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;
}

/**
 * Print an error message
 *
 * @v msg		Error message
 * @v device		Device opaque pointer
 */
static void __asmcall slirp_guest_error ( const char *msg, void *device ) {
	struct net_device *netdev = device;
	struct slirp_nic *slirp = netdev->priv;

	DBGC ( slirp, "SLIRP %p error: %s\n", slirp, msg );
}

/**
 * Get virtual clock
 *
 * @v device		Device opaque pointer
 * @ret clock_ns	Clock time in nanoseconds
 */
static int64_t __asmcall slirp_clock_get_ns ( void *device __unused ) {
	int64_t time;

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

/**
 * Handle timer expiry
 *
 * @v timer		Retry timer
 * @v over		Failure indicator
 */
static void slirp_expired ( struct retry_timer *timer, int over __unused ) {
	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 );
}

/**
 * Create a new timer
 *
 * @v callback		Timer callback
 * @v opaque		Timer opaque pointer
 * @v device		Device opaque pointer
 * @ret timer		Timer
 */
static void * __asmcall
slirp_timer_new ( void ( __asmcall * callback ) ( void *opaque ),
		  void *opaque, void *device ) {
	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;
}

/**
 * Delete a timer
 *
 * @v timer		Timer
 * @v device		Device opaque pointer
 */
static void __asmcall slirp_timer_free ( void *timer, void *device ) {
	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 );
}

/**
 * Set timer expiry time
 *
 * @v timer		Timer
 * @v expire		Expiry time
 * @v device		Device opaque pointer
 */
static void __asmcall slirp_timer_mod ( void *timer, int64_t expire,
					void *device ) {
	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 );
}

/**
 * Register file descriptor for polling
 *
 * @v fd		File descriptor
 * @v device		Device opaque pointer
 */
static void __asmcall slirp_register_poll_fd ( int fd, void *device ) {
	struct net_device *netdev = device;
	struct slirp_nic *slirp = netdev->priv;

	DBGC ( slirp, "SLIRP %p registered FD %d\n", slirp, fd );
}

/**
 * Unregister file descriptor
 *
 * @v fd		File descriptor
 * @v device		Device opaque pointer
 */
static void __asmcall slirp_unregister_poll_fd ( int fd, void *device ) {
	struct net_device *netdev = device;
	struct slirp_nic *slirp = netdev->priv;

	DBGC ( slirp, "SLIRP %p unregistered FD %d\n", slirp, fd );
}

/**
 * Notify that new events are ready
 *
 * @v device		Device opaque pointer
 */
static void __asmcall slirp_notify ( void *device ) {
	struct net_device *netdev = device;
	struct slirp_nic *slirp = netdev->priv;

	DBGC2 ( slirp, "SLIRP %p notified\n", slirp );
}

/** Slirp callbacks */
static struct slirp_callbacks slirp_callbacks = {
	.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,
};

/******************************************************************************
 *
 * Network device interface
 *
 ******************************************************************************
 */

/**
 * Open network device
 *
 * @v netdev		Network device
 * @ret rc		Return status code
 */
static int slirp_open ( struct net_device *netdev ) {
	struct slirp_nic *slirp = netdev->priv;

	/* Nothing to do */
	DBGC ( slirp, "SLIRP %p opened\n", slirp );

	return 0;
}

/**
 * Close network device
 *
 * @v netdev		Network device
 */
static void slirp_close ( struct net_device *netdev ) {
	struct slirp_nic *slirp = netdev->priv;

	/* Nothing to do */
	DBGC ( slirp, "SLIRP %p closed\n", slirp );
}

/**
 * Transmit packet
 *
 * @v netdev		Network device
 * @v iobuf		I/O buffer
 * @ret rc		Return status code
 */
static int slirp_transmit ( struct net_device *netdev,
			    struct io_buffer *iobuf ) {
	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;
}

/**
 * Add polling file descriptor
 *
 * @v fd		File descriptor
 * @v events		Events of interest
 * @v device		Device opaque pointer
 * @ret index		File descriptor index
 */
static int __asmcall slirp_add_poll ( int fd, int events, void *device ) {
	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;
}

/**
 * Get returned events for a file descriptor
 *
 * @v index		File descriptor index
 * @v device		Device opaque pointer
 * @ret events		Returned events
 */
static int __asmcall slirp_get_revents ( int index, void *device ) {
	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;
}

/**
 * Poll for completed and received packets
 *
 * @v netdev		Network device
 */
static void slirp_poll ( struct net_device *netdev ) {
	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 ) );
	}
}

/** Network device operations */
static struct net_device_operations slirp_operations = {
	.open		= slirp_open,
	.close		= slirp_close,
	.transmit	= slirp_transmit,
	.poll		= slirp_poll,
};

/******************************************************************************
 *
 * Linux driver interface
 *
 ******************************************************************************
 */

/**
 * Probe device
 *
 * @v linux		Linux device
 * @v request		Device creation request
 * @ret rc		Return status code
 */
static int slirp_probe ( struct linux_device *linux,
			 struct linux_device_request *request ) {
	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;
}

/**
 * Remove device
 *
 * @v linux		Linux device
 */
static void slirp_remove ( struct linux_device *linux ) {
	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 );
}

/** Slirp driver */
struct linux_driver slirp_driver __linux_driver = {
	.name = "slirp",
	.probe = slirp_probe,
	.remove = slirp_remove,
	.can_probe = 1,
};