openslx-ng/buildroot.git - Scripts preparing a debootstraped chroot-environment and building core components for initial ramfs.

	Commit message (Expand)	Author	Age	Files	Lines
*	Use HOST_GLIB for glib installation instead of /usr/bin	Ulf Samuelsson	2009-01-13	1	-1/+1
*	libpng: fix Makefile.autotools.in fallout	Peter Korsgaard	2008-11-02	1	-1/+1
*	package: remove redundant pkg-config variables	Peter Korsgaard	2008-10-26	1	-9/+4
*	buildroot: remove trailing spaces	Peter Korsgaard	2008-08-04	1	-6/+6
*	Kconfig: remove 'default n'	Peter Korsgaard	2008-07-17	1	-1/+0
*	packages: fix pkgconfig depencies and select pkgconfig where needed	Peter Korsgaard	2008-06-14	2	-1/+2
*	bump to 0.97.1, removed patch as it has been already applied in upstream revi...	John Voltz	2008-04-24	2	-32/+4
*	package: move java packages to package/java sub directory	Peter Korsgaard	2008-03-28	3	-0/+134

/* * 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 <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> /** @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, };