path: root/minix/lib/libnetdriver/netdriver.c

/* The device-independent network driver framework. */

#include <minix/drivers.h>
#include <minix/netdriver.h>
#include <minix/ds.h>
#include <assert.h>

#include "netdriver.h"

/*
 * These maximum values should be at least somewhat synchronized with the
 * values in the LWIP service's ndev module.
 */
#define NETDRIVER_SENDQ_MAX	8
#define NETDRIVER_RECVQ_MAX	2

/*
 * Maximum number of multicast addresses that can be copied in from the TCP/IP
 * service and passed to the driver.  If the actual number from the service
 * exceeds this maximum, the driver will be told to receive all multicast
 * packets instead.
 */
#define NETDRIVER_MCAST_MAX	16

static const struct netdriver *netdriver_table = NULL;

static int running;

static int init_expected;

static int up;

static unsigned int ticks;

static struct netdriver_data pending_sendq[NETDRIVER_SENDQ_MAX];
static unsigned int pending_sends, pending_sendtail;

static struct netdriver_data pending_recvq[NETDRIVER_RECVQ_MAX];
static unsigned int pending_recvs, pending_recvtail;

static int pending_status;
static endpoint_t status_endpt;

static int pending_link, pending_stat;
static uint32_t stat_oerror, stat_coll, stat_ierror, stat_iqdrop;

static char device_name[NDEV_NAME_MAX];
static netdriver_addr_t device_hwaddr;
static uint32_t device_caps;

static unsigned int device_link;
static uint32_t device_media;

/*
 * Announce we are up after a fresh start or restart.
 */
static void
netdriver_announce(void)
{
	const char *driver_prefix = "drv.net.";
	char label[DS_MAX_KEYLEN];
	char key[DS_MAX_KEYLEN];
	int r;

	/* Publish a driver up event. */
	if ((r = ds_retrieve_label_name(label, sef_self())) != OK)
		panic("netdriver: unable to get own label: %d", r);

	snprintf(key, sizeof(key), "%s%s", driver_prefix, label);
	if ((r = ds_publish_u32(key, DS_DRIVER_UP, DSF_OVERWRITE)) != OK)
		panic("netdriver: unable to publish driver up event: %d", r);
}

/*
 * Prepare for copying.  Given a flat offset, return the vector element index
 * and an offset into that element.  Panic if the request does not fall
 * entirely within the vector.
 */
size_t
netdriver_prepare_copy(struct netdriver_data * data, size_t off, size_t size,
	unsigned int * indexp)
{
	unsigned int i;

	assert(data->size > 0);

	/*
	 * In theory we could truncate when copying out, but this creates a
	 * problem for port-based I/O, where the size of the transfer is
	 * typically specified in advance.  We could do extra port-based I/O
	 * to discard the extra bytes, but the driver is better off doing such
	 * truncation itself.  Thus, we disallow copying (in and out) beyond
	 * the given data vector altogether.
	 */
	if (off + size > data->size)
		panic("netdriver: request to copy beyond data size");

	/*
	 * Find the starting offset in the vector.  If this turns out to be
	 * expensive, this can be adapted to store the last <element,offset>
	 * pair in the "data" structure (this is the reason it is not 'const').
	 */
	for (i = 0; i < data->count; i++) {
		assert(data->iovec[i].iov_size > 0);

		if (off >= data->iovec[i].iov_size)
			off -= data->iovec[i].iov_size;
		else
			break;
	}

	assert(i < data->count);

	*indexp = i;
	return off;
}

/*
 * Copy in or out packet data from/to a vector of grants.
 */
static void
netdriver_copy(struct netdriver_data * data, size_t off, vir_bytes addr,
	size_t size, int copyin)
{
	struct vscp_vec vec[SCPVEC_NR];
	size_t chunk;
	unsigned int i, v;
	int r;

	off = netdriver_prepare_copy(data, off, size, &i);

	/* Generate a new vector with all the individual copies to make. */
	for (v = 0; size > 0; v++) {
		chunk = data->iovec[i].iov_size - off;
		if (chunk > size)
			chunk = size;
		assert(chunk > 0);

		/*
		 * We should be able to fit the entire I/O request in a single
		 * copy vector.  If not, MINIX3 has been misconfigured.
		 */
		if (v >= SCPVEC_NR)
			panic("netdriver: invalid vector size constant");

		if (copyin) {
			vec[v].v_from = data->endpt;
			vec[v].v_to = SELF;
		} else {
			vec[v].v_from = SELF;
			vec[v].v_to = data->endpt;
		}
		vec[v].v_gid = data->iovec[i].iov_grant;
		vec[v].v_offset = off;
		vec[v].v_addr = addr;
		vec[v].v_bytes = chunk;

		i++;
		off = 0;
		addr += chunk;
		size -= chunk;
	}

	assert(v > 0 && v <= SCPVEC_NR);

	/*
	 * If only one vector element was generated, use a direct copy.  This
	 * saves the kernel from having to copy in the vector.
	 */
	if (v == 1) {
		if (copyin)
			r = sys_safecopyfrom(vec->v_from, vec->v_gid,
			    vec->v_offset, vec->v_addr, vec->v_bytes);
		else
			r = sys_safecopyto(vec->v_to, vec->v_gid,
			    vec->v_offset, vec->v_addr, vec->v_bytes);
	} else
		r = sys_vsafecopy(vec, v);

	if (r != OK)
		panic("netdriver: unable to copy data: %d", r);
}

/*
 * Copy in packet data.
 */
void
netdriver_copyin(struct netdriver_data * __restrict data, size_t off,
	void * __restrict ptr, size_t size)
{

	netdriver_copy(data, off, (vir_bytes)ptr, size, TRUE /*copyin*/);
}

/*
 * Copy out packet data.
 */
void
netdriver_copyout(struct netdriver_data * __restrict data, size_t off,
	const void * __restrict ptr, size_t size)
{

	netdriver_copy(data, off, (vir_bytes)ptr, size, FALSE /*copyin*/);
}

/*
 * Send a reply to a request.
 */
static void
send_reply(endpoint_t endpt, message * m_ptr)
{
	int r;

	if ((r = asynsend(endpt, m_ptr)) != OK)
		panic("netdriver: unable to send to %d: %d", endpt, r);
}

/*
 * A packet receive request has finished.  Send a reply and clean up.
 */
static void
finish_recv(int32_t result)
{
	struct netdriver_data *data;
	message m;

	assert(pending_recvs > 0);

	data = &pending_recvq[pending_recvtail];

	memset(&m, 0, sizeof(m));
	m.m_type = NDEV_RECV_REPLY;
	m.m_netdriver_ndev_reply.id = data->id;
	m.m_netdriver_ndev_reply.result = result;

	send_reply(data->endpt, &m);

	pending_recvtail = (pending_recvtail + 1) %
	    __arraycount(pending_recvq);
	pending_recvs--;
}

/*
 * Resume receiving packets.  In particular, if a receive request was pending,
 * call the driver's receive function.  If the call is successful, send a reply
 * to the requesting party.
 */
void
netdriver_recv(void)
{
	struct netdriver_data *data;
	ssize_t r;

	assert(netdriver_table != NULL);

	while (pending_recvs > 0) {
		data = &pending_recvq[pending_recvtail];

		/*
		 * For convenience of driver writers: if the receive function
		 * returns zero, simply call it again, to simplify discarding
		 * invalid packets.
		 */
		do {
			r = netdriver_table->ndr_recv(data, data->size);

			/*
			 * The default policy is: drop undersized packets,
			 * panic on oversized packets.  The driver may
			 * implement any other policy (e.g., pad small packets,
			 * drop or truncate large packets), but it should at
			 * least test against the given 'max' value.  The
			 * reason that truncation should be implemented in the
			 * driver rather than here, is explained in an earlier
			 * comment about truncating copy operations.
			 */
			if (r >= 0 && r < NDEV_ETH_PACKET_MIN)
				r = 0;
			else if (r > (ssize_t)data->size)
				panic("netdriver: oversized packet returned: "
				    "%zd", r);
		} while (r == 0);

		if (r == SUSPEND)
			break;

		if (r < 0)
			panic("netdriver: driver reported receive failure: %d",
			    r);

		assert(r >= NDEV_ETH_PACKET_MIN && (size_t)r <= data->size);

		finish_recv(r);
	}
}

/*
 * A packet send request has finished.  Send a reply and clean up.
 */
static void
finish_send(int32_t result)
{
	struct netdriver_data *data;
	message m;

	assert(pending_sends > 0);

	data = &pending_sendq[pending_sendtail];

	memset(&m, 0, sizeof(m));
	m.m_type = NDEV_SEND_REPLY;
	m.m_netdriver_ndev_reply.id = data->id;
	m.m_netdriver_ndev_reply.result = result;

	send_reply(data->endpt, &m);

	pending_sendtail = (pending_sendtail + 1) %
	    __arraycount(pending_sendq);
	pending_sends--;
}

/*
 * Resume sending packets.  In particular, if any send requests were pending,
 * call the driver's send function for each of them, until the driver can take
 * no more.  For each successful request is successful, send a reply to the
 * requesting party.
 */
void
netdriver_send(void)
{
	struct netdriver_data *data;
	int r;

	assert(netdriver_table != NULL);

	while (pending_sends > 0) {
		data = &pending_sendq[pending_sendtail];

		r = netdriver_table->ndr_send(data, data->size);

		if (r == SUSPEND)
			break;

		if (r < 0)
			panic("netdriver: driver reported send failure: %d",
			    r);

		finish_send(r);
	}
}

/*
 * Process a request to send or receive a packet.
 */
static void
do_transfer(const struct netdriver * __restrict ndp, const message * m_ptr,
	int do_write)
{
	struct netdriver_data *data;
	cp_grant_id_t grant;
	size_t size;
	unsigned int i;

	/* Prepare the local data structure. */
	if (do_write) {
		if (pending_sends == __arraycount(pending_sendq))
			panic("netdriver: too many concurrent send requests");

		data = &pending_sendq[(pending_sendtail + pending_sends) %
		    __arraycount(pending_sendq)];
	} else {
		if (pending_recvs == __arraycount(pending_recvq))
			panic("netdriver: too many concurrent receive "
			    "requests");

		data = &pending_recvq[(pending_recvtail + pending_recvs) %
		    __arraycount(pending_recvq)];
	}

	data->endpt = m_ptr->m_source;
	data->id = m_ptr->m_ndev_netdriver_transfer.id;
	data->count = m_ptr->m_ndev_netdriver_transfer.count;

	if (data->count == 0 || data->count > NDEV_IOV_MAX)
		panic("netdriver: bad I/O vector count: %u", data->count);

	data->size = 0;

	for (i = 0; i < data->count; i++) {
		grant = m_ptr->m_ndev_netdriver_transfer.grant[i];
		size = (size_t)m_ptr->m_ndev_netdriver_transfer.len[i];

		assert(size > 0);

		data->iovec[i].iov_grant = grant;
		data->iovec[i].iov_size = size;
		data->size += size;
	}

	if (data->size < NDEV_ETH_PACKET_MIN ||
	    (!do_write && data->size < NDEV_ETH_PACKET_MAX_TAGGED))
		panic("netdriver: invalid I/O vector size: %zu\n", data->size);

	if (do_write)
		pending_sends++;
	else
		pending_recvs++;

	/*
	 * If the driver is down, immediately abort the request again.  This
	 * is not a common case but does occur as part of queue draining by the
	 * TCP/IP stack, and is way easier to handle here than up there..
	 */
	if (!up) {
		if (do_write)
			finish_send(EINTR);
		else
			finish_recv(EINTR);

		return;
	}

	/* Otherwise, resume sending or receiving. */
	if (do_write)
		netdriver_send();
	else
		netdriver_recv();
}

/*
 * Process a request to (re)configure the driver.
 */
static void
do_conf(const struct netdriver * __restrict ndp,
	const message * __restrict m_ptr)
{
	netdriver_addr_t mcast_list[NETDRIVER_MCAST_MAX];
	uint32_t set, mode;
	unsigned int mcast_count;
	message m;
	int r;

	set = m_ptr->m_ndev_netdriver_conf.set;
	mode = m_ptr->m_ndev_netdriver_conf.mode;

	/*
	 * If the request includes taking down the interface, perform that step
	 * first: it is expected that in many cases, changing other settings
	 * requires stopping and restarting the device.
	 */
	if ((set & NDEV_SET_MODE) && mode == NDEV_MODE_DOWN &&
	    ndp->ndr_set_mode != NULL)
		ndp->ndr_set_mode(mode, NULL, 0);

	if ((set & NDEV_SET_CAPS) && ndp->ndr_set_caps != NULL)
		ndp->ndr_set_caps(m_ptr->m_ndev_netdriver_conf.caps);

	if ((set & NDEV_SET_FLAGS) && ndp->ndr_set_flags != NULL)
		ndp->ndr_set_flags(m_ptr->m_ndev_netdriver_conf.flags);

	if ((set & NDEV_SET_MEDIA) && ndp->ndr_set_media != NULL)
		ndp->ndr_set_media(m_ptr->m_ndev_netdriver_conf.media);

	if ((set & NDEV_SET_HWADDR) && ndp->ndr_set_hwaddr != NULL) {
		/* Save the new hardware address. */
		memcpy(&device_hwaddr, m_ptr->m_ndev_netdriver_conf.hwaddr,
		    sizeof(device_hwaddr));

		ndp->ndr_set_hwaddr(&device_hwaddr);
	}

	if ((set & NDEV_SET_MODE) && mode != NDEV_MODE_DOWN &&
	    ndp->ndr_set_mode != NULL) {
		/*
		 * If we have a multicast list, copy it in, unless it is too
		 * large: in that case, enable all-multicast receipt mode.
		 */
		if ((mode & NDEV_MODE_MCAST_LIST) &&
		    m_ptr->m_ndev_netdriver_conf.mcast_count >
		    __arraycount(mcast_list)) {
			mode &= ~NDEV_MODE_MCAST_LIST;
			mode |= NDEV_MODE_MCAST_ALL;
		}

		if (mode & NDEV_MODE_MCAST_LIST) {
			assert(m_ptr->m_ndev_netdriver_conf.mcast_grant !=
			    GRANT_INVALID);

			mcast_count = m_ptr->m_ndev_netdriver_conf.mcast_count;

			if ((r = sys_safecopyfrom(m_ptr->m_source,
			    m_ptr->m_ndev_netdriver_conf.mcast_grant, 0,
			    (vir_bytes)mcast_list,
			    mcast_count * sizeof(mcast_list[0]))) != OK)
				panic("netdriver: unable to copy data: %d", r);

			ndp->ndr_set_mode(mode, mcast_list, mcast_count);
		} else
			ndp->ndr_set_mode(mode, NULL, 0);
	}

	/* We always report OK: the caller cannot do anything upon failure. */
	memset(&m, 0, sizeof(m));
	m.m_type = NDEV_CONF_REPLY;
	m.m_netdriver_ndev_reply.id = m_ptr->m_ndev_netdriver_conf.id;
	m.m_netdriver_ndev_reply.result = OK;

	send_reply(m_ptr->m_source, &m);

	/*
	 * Finally, if the device has been taken down, abort pending send and
	 * receive requests.
	 */
	if (set & NDEV_SET_MODE) {
		if (mode == NDEV_MODE_DOWN) {
			while (pending_sends > 0)
				finish_send(EINTR);

			while (pending_recvs > 0)
				finish_recv(EINTR);

			up = FALSE;
		} else
			up = TRUE;
	}
}

/*
 * Request an update of the link state and active media of the device.  This
 * routine may be called both from the driver and internally.
 */
static void
update_link(void)
{

	if (netdriver_table->ndr_get_link != NULL)
		device_link = netdriver_table->ndr_get_link(&device_media);

	pending_link = FALSE;
}

/*
 * Attempt to send a status update to the endpoint registered to receive status
 * updates, if any.
 */
static void
send_status(void)
{
	message m;
	int r;

	assert(pending_link || pending_stat);

	if (status_endpt == NONE || pending_status)
		return;

	if (pending_link)
		update_link();

	memset(&m, 0, sizeof(m));
	m.m_type = NDEV_STATUS;
	m.m_netdriver_ndev_status.id = 0;	/* for now */
	m.m_netdriver_ndev_status.link = device_link;
	m.m_netdriver_ndev_status.media = device_media;
	m.m_netdriver_ndev_status.oerror = stat_oerror;
	m.m_netdriver_ndev_status.coll = stat_coll;
	m.m_netdriver_ndev_status.ierror = stat_ierror;
	m.m_netdriver_ndev_status.iqdrop = stat_iqdrop;

	if ((r = asynsend3(status_endpt, &m, AMF_NOREPLY)) != OK)
		panic("netdriver: unable to send status: %d", r);

	/*
	 * Do not send another status message until either the one we just sent
	 * gets acknowledged or we get a new initialization request.  This way
	 * we get "natural pacing" (i.e., we avoid overflowing the asynsend
	 * message queue by design) without using timers.
	 */
	pending_status = TRUE;

	/*
	 * The status message sends incremental updates for statistics.  This
	 * means that while a restart of the TCP/IP stack means the statistics
	 * are lost (not great), a restart of the driver leaves the statistics
	 * mostly intact (more important).
	 */
	stat_oerror = 0;
	stat_coll = 0;
	stat_ierror = 0;
	stat_iqdrop = 0;
	pending_stat = FALSE;
}

/*
 * Process a reply to a status update that we sent earlier on (supposedly).
 */
static void
do_status_reply(const struct netdriver * __restrict ndp __unused,
	const message * __restrict m_ptr)
{

	if (m_ptr->m_source != status_endpt)
		return;

	if (!pending_status || m_ptr->m_ndev_netdriver_status_reply.id != 0)
		panic("netdriver: unexpected status reply");

	pending_status = FALSE;

	/*
	 * If the local status has changed since our last status update,
	 * send a new one right away.
	 */
	if (pending_link || pending_stat)
		send_status();
}

/*
 * The driver reports that the link state and/or active media may have changed.
 * When convenient, request the new state from the driver and send a status
 * message to the TCP/IP stack.
 */
void
netdriver_link(void)
{

	pending_link = TRUE;

	send_status();
}

/*
 * The driver reports that a number of output errors have occurred.  Update
 * statistics accordingly.
 */
void
netdriver_stat_oerror(uint32_t count)
{

	if (count == 0)
		return;

	stat_oerror += count;
	pending_stat = TRUE;

	send_status();
}

/*
 * The driver reports that one or more packet collisions have occurred.  Update
 * statistics accordingly.
 */
void
netdriver_stat_coll(uint32_t count)
{

	if (count == 0)
		return;

	stat_coll += count;
	pending_stat = TRUE;

	send_status();
}

/*
 * The driver reports that a number of input errors have occurred.  Adjust
 * statistics accordingly.
 */
void
netdriver_stat_ierror(uint32_t count)
{

	if (count == 0)
		return;

	stat_ierror += count;
	pending_stat = TRUE;

	send_status();
}

/*
 * The driver reports that a number of input queue drops have occurred.  Update
 * statistics accordingly.
 */
void
netdriver_stat_iqdrop(uint32_t count)
{

	if (count == 0)
		return;

	stat_iqdrop += count;
	pending_stat = TRUE;

	send_status();
}

/*
 * Process an initialization request.  Actual initialization has already taken
 * place, so we simply report the information gathered at that time.  If the
 * caller (the TCP/IP stack) has crashed and restarted, we will get another
 * initialization request message, so keep the information up-to-date.
 */
static void
do_init(const struct netdriver * __restrict ndp,
	const message * __restrict m_ptr)
{
	message m;

	/*
	 * First of all, an initialization request is a sure indication that
	 * the caller does not have any send or receive requests pending, and
	 * will not acknowledge our previous status request, if any.  Forget
	 * any such previous requests and start sending status requests to the
	 * (new) endpoint.
	 */
	pending_sends = 0;
	pending_recvs = 0;
	pending_status = FALSE;

	status_endpt = m_ptr->m_source;

	/*
	 * Update link and media now, because we are about to send the initial
	 * values of those to the caller as well.
	 */
	update_link();

	memset(&m, 0, sizeof(m));
	m.m_type = NDEV_INIT_REPLY;
	m.m_netdriver_ndev_init_reply.id = m_ptr->m_ndev_netdriver_init.id;
	m.m_netdriver_ndev_init_reply.link = device_link;
	m.m_netdriver_ndev_init_reply.media = device_media;
	m.m_netdriver_ndev_init_reply.caps = device_caps;
	strlcpy(m.m_netdriver_ndev_init_reply.name, device_name,
	    sizeof(m.m_netdriver_ndev_init_reply.name));
	assert(sizeof(device_hwaddr) <=
	    sizeof(m.m_netdriver_ndev_init_reply.hwaddr));
	memcpy(m.m_netdriver_ndev_init_reply.hwaddr, &device_hwaddr,
	    sizeof(device_hwaddr));
	m.m_netdriver_ndev_init_reply.hwaddr_len = sizeof(device_hwaddr);

	m.m_netdriver_ndev_init_reply.max_send = __arraycount(pending_sendq);
	m.m_netdriver_ndev_init_reply.max_recv = __arraycount(pending_recvq);

	send_reply(m_ptr->m_source, &m);

	/*
	 * Also send the current status.  This is not required by the protocol
	 * and only serves to provide updated statistics to a new TCP/IP stack
	 * instance right away.
	 */
	if (pending_stat)
		send_status();
}

/*
 * Process an incoming message, and send a reply.
 */
void
netdriver_process(const struct netdriver * __restrict ndp,
	const message * __restrict m_ptr, int ipc_status)
{

	netdriver_table = ndp;

	/* Check for notifications first. */
	if (is_ipc_notify(ipc_status)) {
		switch (m_ptr->m_source) {
		case HARDWARE:
			if (ndp->ndr_intr != NULL)
				ndp->ndr_intr(m_ptr->m_notify.interrupts);
			break;

		case CLOCK:
			if (ndp->ndr_tick != NULL)
				ndp->ndr_tick();

			if (ticks > 0)
				(void)sys_setalarm(ticks, FALSE /*abs_time*/);
			break;

		default:
			if (ndp->ndr_other != NULL)
				ndp->ndr_other(m_ptr, ipc_status);
		}

		return;
	}

	/*
	 * Discard datalink requests preceding a first NDEV_INIT request, so
	 * that after a driver restart, any in-flight request is discarded.
	 * Note that for correct driver operation it is important that
	 * non-datalink requests, and interrupts in particular, do not go
	 * through this check.
	 */
	if (IS_NDEV_RQ(m_ptr->m_type) && init_expected) {
		if (m_ptr->m_type != NDEV_INIT)
			return; /* do not send a reply */

		init_expected = FALSE;
	}

	switch (m_ptr->m_type) {
	case NDEV_INIT:
		do_init(ndp, m_ptr);
		break;

	case NDEV_CONF:
		do_conf(ndp, m_ptr);
		break;

	case NDEV_SEND:
		do_transfer(ndp, m_ptr, TRUE /*do_write*/);
		break;

	case NDEV_RECV:
		do_transfer(ndp, m_ptr, FALSE /*do_write*/);
		break;

	case NDEV_STATUS_REPLY:
		do_status_reply(ndp, m_ptr);
		break;

	default:
		if (ndp->ndr_other != NULL)
			ndp->ndr_other(m_ptr, ipc_status);
	}
}

/*
 * Set a name for the device, based on the base name 'base' and the instance
 * number 'instance'.
 */
static void
netdriver_set_name(const char * base, unsigned int instance)
{
	size_t len;

	assert(instance <= 255);

	len = strlen(base);
	assert(len <= sizeof(device_name) - 4);

	memcpy(device_name, base, len);
	if (instance >= 100)
		device_name[len++] = '0' + instance / 100;
	if (instance >= 10)
		device_name[len++] = '0' + (instance % 100) / 10;
	device_name[len++] = '0' + instance % 10;
	device_name[len] = 0;
}

/*
 * Return the device name generated at driver initialization time.
 */
const char *
netdriver_name(void)
{

	return device_name;
}

/*
 * Perform initialization.  Return OK or an error code.
 */
int
netdriver_init(const struct netdriver * ndp)
{
	unsigned int instance;
	long v;
	int r;

	/* Initialize global variables. */
	pending_sendtail = 0;
	pending_sends = 0;
	pending_recvtail = 0;
	pending_recvs = 0;

	memset(device_name, 0, sizeof(device_name));

	memset(&device_hwaddr, 0, sizeof(device_hwaddr));
	device_caps = 0;

	/* Use sensible defaults for the link state and active media. */
	device_link = NDEV_LINK_UNKNOWN;
	device_media = IFM_MAKEWORD(IFM_ETHER, IFM_AUTO, 0, 0);

	status_endpt = NONE;
	pending_status = FALSE;
	pending_link = FALSE;

	up = FALSE;

	ticks = 0;

	/* Get the device instance number. */
	v = 0;
	(void)env_parse("instance", "d", 0, &v, 0, 255);
	instance = (unsigned int)v;

	/* Generate the full driver name. */
	netdriver_set_name(ndp->ndr_name, instance);

	/* Call the initialization routine. */
	if ((r = ndp->ndr_init(instance, &device_hwaddr, &device_caps,
	    &ticks)) != OK)
		return r;

	/* Announce we are up! */
	netdriver_announce();

	init_expected = TRUE;
	running = TRUE;

	if (ticks > 0)
		(void)sys_setalarm(ticks, FALSE /*abs_time*/);

	return OK;
}

/*
 * Perform SEF initialization.
 */
static int
local_init(int type __unused, sef_init_info_t * info __unused)
{

	assert(netdriver_table != NULL);

	return netdriver_init(netdriver_table);
}

/*
 * Break out of the main loop after finishing the current request.
 */
void
netdriver_terminate(void)
{

	if (netdriver_table != NULL && netdriver_table->ndr_stop != NULL)
		netdriver_table->ndr_stop();

	running = FALSE;

	sef_cancel();
}

/*
 * The process has received a signal.  See if we have to terminate.
 */
static void
got_signal(int sig)
{

	if (sig != SIGTERM)
		return;

	netdriver_terminate();
}

/*
 * Main program of any network driver.
 */
void
netdriver_task(const struct netdriver * ndp)
{
	message mess;
	int r, ipc_status;

	/* Perform SEF initialization. */
	sef_setcb_init_fresh(local_init);
	sef_setcb_signal_handler(got_signal);

	netdriver_table = ndp;

	sef_startup();

	/* The main message loop. */
	while (running) {
		if ((r = sef_receive_status(ANY, &mess, &ipc_status)) != OK) {
			if (r == EINTR)
				continue;	/* sef_cancel() was called */

			panic("netdriver: sef_receive_status failed: %d", r);
		}

		netdriver_process(ndp, &mess, ipc_status);
	}
}