Kill off hotplug.h and just make net devices normal reference-counted

structures.

DHCP still broken and #if 0'd out.

src/arch/i386/drivers/net/undinet.c

 	undinet_call ( undinic, PXENV_STOP_UNDI, &stop_undi,
 		       sizeof ( stop_undi ) );
  err_start_undi:
-	free_netdev ( netdev );
+	netdev_put ( netdev );
 	undi_set_drvdata ( undi, NULL );
 	return rc;
 }
 	undi->flags &= ~UNDI_FL_STARTED;
 
 	/* Free network device */
-	free_netdev ( netdev );
+	netdev_put ( netdev );
 
 	DBGC ( undinic, "UNDINIC %p removed\n", undinic );
 }

src/core/hotplug.c

-/*
- * Copyright (C) 2007 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., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <assert.h>
-#include <gpxe/hotplug.h>
-
-/** @file
- *
- * Hotplug support
- *
- */
-
-/**
- * Forget all persistent references to an object
- *
- * @v list		List of persistent references
- */
-void forget_references ( struct list_head *list ) {
-	struct reference *ref;
-	struct reference *ref_tmp;
-
-	list_for_each_entry_safe ( ref, ref_tmp, list, list ) {
-		ref->forget ( ref );
-	}
-
-	/* The list had really better be empty by now, otherwise we're
-	 * screwed.
-	 */
-	assert ( list_empty ( list ) );
-}

src/drivers/net/legacy.c

 	nic.node_addr = netdev->ll_addr;
 
 	if ( ! probe ( &nic, hwdev ) ) {
-		free_netdev ( netdev );
+		netdev_put ( netdev );
 		return -ENODEV;
 	}
 
 	if ( ( rc = register_netdev ( netdev ) ) != 0 ) {
 		disable ( &nic, hwdev );
-		free_netdev ( netdev );
+		netdev_put ( netdev );
 		return rc;
 	}
 
 
 	unregister_netdev ( netdev );
 	disable ( nic, hwdev );
-	free_netdev ( netdev );
+	netdev_put ( netdev );
 	legacy_registered = 0;
 }
 

src/drivers/net/pnic.c

 
 	unregister_netdev ( netdev );
 	pnic_command ( pnic, PNIC_CMD_RESET, NULL, 0, NULL, 0, NULL );
-	free_netdev ( netdev );
+	netdev_put ( netdev );
 }
 
 /**************************************************************************
 	uint16_t status;
 	int rc;
 
-	/* Fix up PCI device */
-	adjust_pci_device ( pci );
-	
 	/* Allocate net device */
 	netdev = alloc_etherdev ( sizeof ( *pnic ) );
-	if ( ! netdev ) {
-		rc = -ENOMEM;
-		goto err;
-	}
+	if ( ! netdev )
+		return -ENOMEM;
 	pnic = netdev->priv;
 	pci_set_drvdata ( pci, netdev );
 	netdev->dev = &pci->dev;
 	pnic->ioaddr = pci->ioaddr;
 
+	/* Fix up PCI device */
+	adjust_pci_device ( pci );
+	
 	/* API version check */
 	status = pnic_command_quiet ( pnic, PNIC_CMD_API_VER, NULL, 0,
 				      &api_version,
 
  err:
 	/* Free net device */
-	free_netdev ( netdev );
+	netdev_put ( netdev );
 	return rc;
 }
 

src/drivers/net/rtl8139.c

 static int rtl_probe ( struct pci_device *pci,
 		       const struct pci_device_id *id __unused ) {
 	struct net_device *netdev;
-	struct rtl8139_nic *rtl = NULL;
-	int registered_netdev = 0;
+	struct rtl8139_nic *rtl;
 	int rc;
 
-	/* Fix up PCI device */
-	adjust_pci_device ( pci );
-
 	/* Allocate net device */
 	netdev = alloc_etherdev ( sizeof ( *rtl ) );
-	if ( ! netdev ) {
-		rc = -ENOMEM;
-		goto err;
-	}
+	if ( ! netdev )
+		return -ENOMEM;
 	rtl = netdev->priv;
 	pci_set_drvdata ( pci, netdev );
 	netdev->dev = &pci->dev;
 	memset ( rtl, 0, sizeof ( *rtl ) );
 	rtl->ioaddr = pci->ioaddr;
 
+	/* Fix up PCI device */
+	adjust_pci_device ( pci );
+
 	/* Reset the NIC, set up EEPROM access and read MAC address */
 	rtl_reset ( rtl );
 	rtl_init_eeprom ( rtl );
 
 	/* Register network device */
 	if ( ( rc = register_netdev ( netdev ) ) != 0 )
-		goto err;
-	registered_netdev = 1;
+		goto err_register_netdev;
 
 	/* Register non-volatile storage */
 	if ( rtl->nvo.nvs ) {
 		if ( ( rc = nvo_register ( &rtl->nvo ) ) != 0 )
-			goto err;
+			goto err_register_nvo;
 	}
 
 	return 0;
 
- err:
-	/* Disable NIC */
-	if ( rtl )
-		rtl_reset ( rtl );
-	if ( registered_netdev )
-		unregister_netdev ( netdev );
-	/* Free net device */
-	free_netdev ( netdev );
+ err_register_nvo:
+	unregister_netdev ( netdev );
+ err_register_netdev:
+	rtl_reset ( rtl );
+	netdev_put ( netdev );
 	return rc;
 }
 
 		nvo_unregister ( &rtl->nvo );
 	unregister_netdev ( netdev );
 	rtl_reset ( rtl );
-	free_netdev ( netdev );
+	netdev_put ( netdev );
 }
 
 static struct pci_device_id rtl8139_nics[] = {

src/include/gpxe/aoe.h

 #include <gpxe/retry.h>
 #include <gpxe/async.h>
 #include <gpxe/ata.h>
-#include <gpxe/hotplug.h>
 
 /** An AoE ATA command */
 struct aoecmd {
 
 	/** Network device */
 	struct net_device *netdev;
-	/** Reference to network device */
-	struct reference netdev_ref;
 
 	/** Major number */
 	uint16_t major;

src/include/gpxe/dhcp.h

 #include <gpxe/udp.h>
 #include <gpxe/async.h>
 #include <gpxe/retry.h>
-#include <gpxe/hotplug.h>
 
 /** BOOTP/DHCP server port */
 #define BOOTPS_PORT 67
 	struct dhcp_option_block options[NUM_OPT_BLOCKS];
 };
 
+struct udp_connection {};
+
 /** A DHCP session */
 struct dhcp_session {
 	/** UDP connection for this session */
 
 	/** Network device being configured */
 	struct net_device *netdev;
-	/** Persistent reference to network device */
-	struct reference netdev_ref;
 
 	/** Options obtained from server */
 	struct dhcp_option_block *options;

src/include/gpxe/hotplug.h

-#ifndef _GPXE_HOTPLUG_H
-#define _GPXE_HOTPLUG_H
-
-/** @file
- *
- * Hotplug support
- *
- */
-
-#include <gpxe/list.h>
-
-/**
- * A persistent reference to another data structure
- *
- * This data structure should be embedded within any data structure
- * (the referrer) which holds a persistent reference to a separate,
- * volatile data structure (the referee).
- */
-struct reference {
-	/** List of persistent references */
-	struct list_head list;
-	/** Forget persistent reference
-	 *
-	 * @v ref		Persistent reference
-	 *
-	 * This method is called immediately before the referred-to
-	 * data structure is destroyed.  The reference holder must
-	 * forget all references to the referee before returning from
-	 * this method.
-	 *
-	 * This method must also call ref_del() to remove the
-	 * reference.
-	 */
-	void ( * forget ) ( struct reference *ref );
-};
-
-/**
- * Add persistent reference
- *
- * @v ref		Persistent reference
- * @v list		List of persistent references
- */
-static inline void ref_add ( struct reference *ref, struct list_head *list ) {
-	list_add ( &ref->list, list );
-}
-
-/**
- * Remove persistent reference
- *
- * @v ref		Persistent reference
- */
-static inline void ref_del ( struct reference *ref ) {
-	list_del ( &ref->list );
-}
-
-extern void forget_references ( struct list_head *list );
-
-#endif /* _GPXE_HOTPLUG_H */

src/include/gpxe/ip.h

 
 #include <ip.h>
 #include <gpxe/retry.h>
-#include <gpxe/hotplug.h>
 
 /* IP constants */
 
 
 	/** Network device */
 	struct net_device *netdev;
-	/** Reference to network device */
-	struct reference netdev_ref;
 
 	/** IPv4 address */
 	struct in_addr address;

src/include/gpxe/netdevice.h

 #include <stdint.h>
 #include <gpxe/list.h>
 #include <gpxe/tables.h>
-#include <gpxe/hotplug.h>
+#include <gpxe/refcnt.h>
 
 struct io_buffer;
 struct net_device;
  * not just an Ethernet device.
  */
 struct net_device {
+	/** Reference counter */
+	struct refcnt refcnt;
 	/** List of network devices */
 	struct list_head list;
 	/** Name of this network device */
 	char name[8];
 	/** Underlying hardware device */
 	struct device *dev;
-	/** List of persistent reference holders */
-	struct list_head references;
 
 	/** Open network device
 	 *
 	return ( ! list_empty ( &net_devices ) );
 }
 
+/**
+ * Get reference to network device
+ *
+ * @v netdev		Network device
+ * @ret netdev		Network device
+ */
+static inline __attribute__ (( always_inline )) struct net_device *
+netdev_get ( struct net_device *netdev ) {
+	ref_get ( &netdev->refcnt );
+	return netdev;
+}
+
+/**
+ * Drop reference to network device
+ *
+ * @v netdev		Network device
+ */
+static inline __attribute__ (( always_inline )) void
+netdev_put ( struct net_device *netdev ) {
+	ref_put ( &netdev->refcnt );
+}
+
 extern int netdev_tx ( struct net_device *netdev, struct io_buffer *iobuf );
 void netdev_tx_complete ( struct net_device *netdev, struct io_buffer *iobuf );
 void netdev_tx_complete_next ( struct net_device *netdev );
 extern int netdev_open ( struct net_device *netdev );
 extern void netdev_close ( struct net_device *netdev );
 extern void unregister_netdev ( struct net_device *netdev );
-extern void free_netdev ( struct net_device *netdev );
 struct net_device * find_netdev ( const char *name );
 struct net_device * find_pci_netdev ( unsigned int busdevfn );
 

src/net/aoe.c

 	.rx = aoe_rx,
 };
 
-/**
- * Forget reference to net_device
- *
- * @v ref		Persistent reference
- */
-static void aoe_forget_netdev ( struct reference *ref ) {
-	struct aoe_session *aoe
-		= container_of ( ref, struct aoe_session, netdev_ref );
-
-	aoe->netdev = NULL;
-	ref_del ( &aoe->netdev_ref );
-}
-
 /**
  * Open AoE session
  *
 		 sizeof ( aoe->target ) );
 	aoe->tag = AOE_TAG_MAGIC;
 	aoe->timer.expired = aoe_timer_expired;
-	aoe->netdev_ref.forget = aoe_forget_netdev;
-	ref_add ( &aoe->netdev_ref, &aoe->netdev->references );
 	list_add ( &aoe->list, &aoe_sessions );
 }
 
  * @v aoe		AoE session
  */
 void aoe_close ( struct aoe_session *aoe ) {
-	if ( aoe->netdev )
-		ref_del ( &aoe->netdev_ref );
 	list_del ( &aoe->list );
 }
 

src/net/ipv4.c

 /** List of fragment reassembly buffers */
 static LIST_HEAD ( frag_buffers );
 
-static void ipv4_forget_netdev ( struct reference *ref );
-
 /**
  * Add IPv4 minirouting table entry
  *
 	}
 
 	/* Record routing information */
-	miniroute->netdev = netdev;
+	miniroute->netdev = netdev_get ( netdev );
 	miniroute->address = address;
 	miniroute->netmask = netmask;
 	miniroute->gateway = gateway;
 		list_add ( &miniroute->list, &ipv4_miniroutes );
 	}
 
-	/* Record reference to net_device */
-	miniroute->netdev_ref.forget = ipv4_forget_netdev;
-	ref_add ( &miniroute->netdev_ref, &netdev->references );
-
 	return miniroute;
 }
 
 		DBG ( "gw %s ", inet_ntoa ( miniroute->gateway ) );
 	DBG ( "via %s\n", miniroute->netdev->name );
 
-	ref_del ( &miniroute->netdev_ref );
+	netdev_put ( miniroute->netdev );
 	list_del ( &miniroute->list );
 	free ( miniroute );
 }
 
-/**
- * Forget reference to net_device
- *
- * @v ref		Persistent reference
- */
-static void ipv4_forget_netdev ( struct reference *ref ) {
-	struct ipv4_miniroute *miniroute
-		= container_of ( ref, struct ipv4_miniroute, netdev_ref );
-
-	del_ipv4_miniroute ( miniroute );
-}
-
 /**
  * Add IPv4 interface
  *

src/net/ipv6.c

 
 	/* Network device */
 	struct net_device *netdev;
-	/** Reference to network device */
-	struct reference netdev_ref;
 
 	/* Destination prefix */
 	struct in6_addr prefix;
 /** List of IPv6 miniroutes */
 static LIST_HEAD ( miniroutes );
 
-static void ipv6_forget_netdev ( struct reference *ref );
-
 /**
  * Add IPv6 minirouting table entry
  *
 	miniroute = malloc ( sizeof ( *miniroute ) );
 	if ( miniroute ) {
 		/* Record routing information */
-		miniroute->netdev = netdev;
+		miniroute->netdev = netdev_get ( netdev );
 		miniroute->prefix = prefix;
 		miniroute->prefix_len = prefix_len;
 		miniroute->address = address;
 		} else {
 			list_add ( &miniroute->list, &miniroutes );
 		}
-
-		/* Record reference to net_device */
-		miniroute->netdev_ref.forget = ipv6_forget_netdev;
-		ref_add ( &miniroute->netdev_ref, &netdev->references );
 	}
 
 	return miniroute;
  * @v miniroute		Routing table entry
  */
 static void del_ipv6_miniroute ( struct ipv6_miniroute *miniroute ) {
-	ref_del ( &miniroute->netdev_ref );
+	netdev_put ( miniroute->netdev );
 	list_del ( &miniroute->list );
 	free ( miniroute );
 }
 
-/**
- * Forget reference to net_device
- *
- * @v ref		Persistent reference
- */
-static void ipv6_forget_netdev ( struct reference *ref ) {
-	struct ipv6_miniroute *miniroute
-		= container_of ( ref, struct ipv6_miniroute, netdev_ref );
-
-	del_ipv6_miniroute ( miniroute );
-}
-
 /**
  * Add IPv6 interface
  *

src/net/netdevice.c

 	}
 }
 
+/**
+ * Flush device's transmit queue
+ *
+ * @v netdev		Network device
+ */
+static void netdev_tx_flush ( struct net_device *netdev ) {
+
+	/* Discard any packets in the TX queue */
+	while ( ! list_empty ( &netdev->tx_queue ) ) {
+		netdev_tx_complete_next ( netdev );
+	}
+}
+
 /**
  * Add packet to receive queue
  *
 	return NULL;
 }
 
+/**
+ * Flush device's receive queue
+ *
+ * @v netdev		Network device
+ */
+static void netdev_rx_flush ( struct net_device *netdev ) {
+	struct io_buffer *iobuf;
+
+	/* Discard any packets in the RX queue */
+	while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
+		DBGC ( netdev, "NETDEV %p discarding received %p\n",
+		       netdev, iobuf );
+		free_iob ( iobuf );
+	}
+}
+
+/**
+ * Free network device
+ *
+ * @v refcnt		Network device reference counter
+ */
+static void free_netdev ( struct refcnt *refcnt ) {
+	struct net_device *netdev =
+		container_of ( refcnt, struct net_device, refcnt );
+	
+	netdev_tx_flush ( netdev );
+	netdev_rx_flush ( netdev );
+	free ( netdev );
+}
+
 /**
  * Allocate network device
  *
 	netdev = malloc ( total_len );
 	if ( netdev ) {
 		memset ( netdev, 0, total_len );
-		INIT_LIST_HEAD ( &netdev->references );
+		netdev->refcnt.free = free_netdev;
 		INIT_LIST_HEAD ( &netdev->tx_queue );
 		INIT_LIST_HEAD ( &netdev->rx_queue );
 		netdev->priv = ( ( ( void * ) netdev ) + sizeof ( *netdev ) );
 		   ifindex++ );
 
 	/* Add to device list */
+	netdev_get ( netdev );
 	list_add_tail ( &netdev->list, &net_devices );
 	DBGC ( netdev, "NETDEV %p registered as %s (phys %s hwaddr %s)\n",
 	       netdev, netdev->name, netdev->dev->name,
  * @v netdev		Network device
  */
 void netdev_close ( struct net_device *netdev ) {
-	struct io_buffer *iobuf;
 
 	/* Do nothing if device is already closed */
 	if ( ! ( netdev->state & NETDEV_OPEN ) )
 	/* Close the device */
 	netdev->close ( netdev );
 
-	/* Discard any packets in the TX queue */
-	while ( ! list_empty ( &netdev->tx_queue ) ) {
-		netdev_tx_complete_next ( netdev );
-	}
-
-	/* Discard any packets in the RX queue */
-	while ( ( iobuf = netdev_rx_dequeue ( netdev ) ) ) {
-		DBGC ( netdev, "NETDEV %p discarding received %p\n",
-		       netdev, iobuf );
-		free_iob ( iobuf );
-	}
+	/* Flush TX and RX queues */
+	netdev_tx_flush ( netdev );
+	netdev_rx_flush ( netdev );
 
 	/* Mark as closed */
 	netdev->state &= ~NETDEV_OPEN;
 	/* Ensure device is closed */
 	netdev_close ( netdev );
 
-	/* Kill off any persistent references to this device */
-	forget_references ( &netdev->references );
-
 	/* Remove from device list */
 	list_del ( &netdev->list );
+	netdev_put ( netdev );
 	DBGC ( netdev, "NETDEV %p unregistered\n", netdev );
 }
 
-/**
- * Free network device
- *
- * @v netdev		Network device
- */
-void free_netdev ( struct net_device *netdev ) {
-	free ( netdev );
-}
-
 /**
  * Get network device by name
  *

src/net/udp.c

  * @ret rc		Return status code
  */
 int udp_open ( struct xfer_interface *xfer, struct sockaddr *peer,
-		      struct sockaddr *local ) {
+	       struct sockaddr *local ) {
 	return udp_open_common ( xfer, peer, local, 0 );
 }
 

src/net/udp/dhcp.c

 	return container_of ( conn, struct dhcp_session, udp );
 }
 
+#if 0
+
 /**
  * Mark DHCP session as complete
  *
 	/* Close UDP connection */
 	udp_close ( &dhcp->udp );
 
-	/* Release reference on net device */
-	ref_del ( &dhcp->netdev_ref );
-
 	/* Mark async operation as complete */
 	async_done ( &dhcp->async, rc );
 }
 	.newdata	= dhcp_newdata,
 };
 
-/**
- * Forget reference to net_device
- *
- * @v ref		Persistent reference
- */
-static void dhcp_forget_netdev ( struct reference *ref ) {
-	struct dhcp_session *dhcp
-		= container_of ( ref, struct dhcp_session, netdev_ref );
-
-	/* Kill DHCP session immediately */
-	dhcp_done ( dhcp, -ENETUNREACH );
-}
-
 /**
  * Initiate DHCP on a network interface
  *
 	if ( ( rc = udp_open ( &dhcp->udp, htons ( BOOTPC_PORT ) ) ) != 0 )
 		return rc;
 
-	/* Add persistent reference to net device */
-	dhcp->netdev_ref.forget = dhcp_forget_netdev;
-	ref_add ( &dhcp->netdev_ref, &dhcp->netdev->references );
-
 	/* Proof of concept: just send a single DHCPDISCOVER */
 	dhcp_send_request ( dhcp );
 
 	async_init ( &dhcp->async, &default_async_operations, parent );
 	return 0;
 }
+
+
+#endif