Separated out initialisation functions from startup/shutdown functions.

src/arch/i386/core/cpu.c

 	identify_cpu(&cpu_info);
 }
 
-INIT_FN ( INIT_CPU, cpu_setup, NULL );
-
 #endif /* CONFIG_X86_64 */

src/arch/i386/core/gdbsym.c

 	getkey();
 }
 
-INIT_FN ( INIT_GDBSYM, gdb_symbol_line, NULL );
+struct startup_fn gdb_startup_fn __startup_fn ( STARTUP_NORMAL ) = {
+	.startup = gdb_symbol_line,
+};

src/arch/i386/core/i386_timer.c

 
 #endif /* RTC_CURRTICKS */
 
-INIT_FN ( INIT_TIMERS, setup_timers, NULL );
+struct init_fn timer_init_fn __init_fn ( INIT_NORMAL ) = {
+	.initialise = setup_timers,
+};

src/arch/i386/core/video_subr.c

 	.disabled = 1,
 };
 
-INIT_FN ( INIT_CONSOLE, video_init, NULL );
+struct init_fn video_init_fn __init_fn ( INIT_EARLY ) = {
+	.initialise = video_init,
+};

src/arch/i386/firmware/pcbios/hidemem.c

 #include <realmode.h>
 #include <biosint.h>
 #include <basemem.h>
+#include <gpxe/init.h>
 #include <gpxe/hidemem.h>
 
 /** Alignment for hidden memory regions */
  * Installs an INT 15 handler to edit Etherboot out of the memory map
  * returned by the BIOS.
  */
-void hide_etherboot ( void ) {
+static void hide_etherboot ( void ) {
 
 	/* Initialise the hidden regions */
 	hide_text();
  * Uninstalls the INT 15 handler installed by hide_etherboot(), if
  * possible.
  */
-void unhide_etherboot ( void ) {
+static void unhide_etherboot ( void ) {
 
 	/* If we have more than one hooked interrupt at this point, it
 	 * means that some other vector is still hooked, in which case
 	unhook_bios_interrupt ( 0x15, ( unsigned int ) int15,
 				&int15_vector );
 }
+
+/** Hide Etherboot startup function */
+struct startup_fn hide_etherboot_startup_fn __startup_fn ( EARLY_STARTUP ) = {
+	.startup = hide_etherboot,
+	.shutdown = unhide_etherboot,
+};

src/arch/i386/image/bzimage.c

 #include <gpxe/image.h>
 #include <gpxe/segment.h>
 #include <gpxe/memmap.h>
-#include <gpxe/shutdown.h>
+#include <gpxe/init.h>
 #include <gpxe/initrd.h>
 
 struct image_type bzimage_image_type __image_type ( PROBE_NORMAL );

src/arch/i386/image/eltorito.c

 #include <gpxe/image.h>
 #include <gpxe/segment.h>
 #include <gpxe/ramdisk.h>
-#include <gpxe/shutdown.h>
+#include <gpxe/init.h>
 
 #define ISO9660_BLKSIZE 2048
 #define ELTORITO_VOL_DESC_OFFSET ( 17 * ISO9660_BLKSIZE )

src/arch/i386/image/multiboot.c

 #include <gpxe/segment.h>
 #include <gpxe/memmap.h>
 #include <gpxe/elf.h>
-#include <gpxe/shutdown.h>
+#include <gpxe/init.h>
 
 struct image_type multiboot_image_type __image_type ( PROBE_MULTIBOOT );
 

src/arch/i386/image/nbi.c

 #include <basemem_packet.h>
 #include <gpxe/uaccess.h>
 #include <gpxe/segment.h>
-#include <gpxe/shutdown.h>
+#include <gpxe/init.h>
 #include <gpxe/netdevice.h>
 #include <gpxe/dhcp.h>
 #include <gpxe/image.h>

src/core/heap.c

-#include <gpxe/malloc.h>
-#include <gpxe/heap.h>
-
-/**
- * @file
- *
- * Heap
- *
- */
-
-/**
- * Heap size
- *
- * Currently fixed at 128kB.
- */
-#define HEAP_SIZE ( 128 * 1024 )
-
-/** The heap itself */
-char heap[HEAP_SIZE] __attribute__ (( aligned ( __alignof__(void *) )));
-
-/**
- * Initialise the heap
- *
- */
-void init_heap ( void ) {
-	mpopulate ( heap, sizeof ( heap ) );
-}

src/core/init.c

-/**************************************************************************
- * call_{init,reset,exit}_fns ()
- * 
- * Call the various initialisation and exit functions.  We use a
- * function table so that we don't end up dragging in an object just
- * because we call its initialisation function.
- **************************************************************************
+/*
+ * 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 <gpxe/device.h>
 #include <gpxe/init.h>
 
+/** @file
+ *
+ * Initialisation, startup and shutdown routines
+ *
+ */
+
+/** Registered initialisation functions */
 static struct init_fn init_fns[0]
-	__table_start ( struct init_fn, init_fn );
+	__table_start ( struct init_fn, init_fns );
 static struct init_fn init_fns_end[0]
-	__table_end ( struct init_fn, init_fn );
+	__table_end ( struct init_fn, init_fns );
+
+/** Registered startup/shutdown functions */
+static struct startup_fn startup_fns[0]
+	__table_start ( struct startup_fn, startup_fns );
+static struct startup_fn startup_fns_end[0]
+	__table_end ( struct startup_fn, startup_fns );
 
-void call_init_fns ( void ) {
+/** "startup() has been called" flag */
+static int started = 0;
+
+/**
+ * Initialise gPXE
+ *
+ * This function performs the one-time-only and irreversible
+ * initialisation steps, such as initialising the heap.  It must be
+ * called before (almost) any other function.
+ *
+ * There is, by definition, no counterpart to this function on the
+ * shutdown path.
+ */
+void initialise ( void ) {
 	struct init_fn *init_fn;
 
-	for ( init_fn = init_fns; init_fn < init_fns_end ; init_fn++ ) {
-		if ( init_fn->init )
-			init_fn->init ();
+	/* Call registered initialisation functions */
+	for ( init_fn = init_fns ; init_fn < init_fns_end ; init_fn++ ) {
+		init_fn->initialise ();
 	}
 }
 
-void call_exit_fns ( void ) {
-	struct init_fn *init_fn;
+/**
+ * Start up gPXE
+ *
+ * This function performs the repeatable initialisation steps, such as
+ * probing devices.  You may call startup() and shutdown() multiple
+ * times (as is done via the PXE API when PXENV_START_UNDI is used).
+ */
+void startup ( void ) {
+	struct startup_fn *startup_fn;
+
+	if ( started )
+		return;
+
+	/* Call registered startup functions */
+	for ( startup_fn = startup_fns ; startup_fn < startup_fns_end ;
+	      startup_fn++ ) {
+		if ( startup_fn->startup )
+			startup_fn->startup();
+	}
 
-	/* 
-	 * Exit functions are called in reverse order to
-	 * initialisation functions.
+	/* Probe for all devices.  Treated separately because nothing
+	 * else will drag in device.o
 	 */
-	for ( init_fn = init_fns_end - 1; init_fn >= init_fns ; init_fn-- ) {
-		if ( init_fn->exit )
-			init_fn->exit ();
+	probe_devices();
+
+	started = 1;
+}
+
+/**
+ * Shut down gPXE
+ *
+ * This function reverses the actions of startup(), and leaves gPXE in
+ * a state ready to be removed from memory.  You may call startup()
+ * again after calling shutdown().
+
+ * Call this function only once, before either exiting main() or
+ * starting up a non-returnable image.
+ */
+void shutdown ( void ) {
+	struct startup_fn *startup_fn;
+
+	if ( ! started )
+		return;
+
+	/* Remove all devices */
+	remove_devices();
+
+	/* Call registered shutdown functions (in reverse order) */
+	for ( startup_fn = startup_fns_end - 1 ; startup_fn >= startup_fns ;
+	      startup_fn-- ) {
+		if ( startup_fn->shutdown )
+			startup_fn->shutdown();
 	}
+
+	started = 0;
 }

src/core/main.c

 /**************************************************************************
-Etherboot -  Network Bootstrap Program
+gPXE -  Network Bootstrap Program
 
 Literature dealing with the network protocols:
 	ARP - RFC826
 
 **************************************************************************/
 
-#include <gpxe/heap.h>
 #include <gpxe/init.h>
-#include <gpxe/process.h>
-#include <gpxe/device.h>
 #include <gpxe/shell.h>
 #include <gpxe/shell_banner.h>
-#include <gpxe/shutdown.h>
-#include <gpxe/hidemem.h>
 #include <usr/autoboot.h>
 
-/**
- * Start up Etherboot
- *
- * Call this function only once, before doing (almost) anything else.
- */
-static void startup ( void ) {
-	init_heap();
-	init_processes();
-
-	hide_etherboot();
-	call_init_fns();
-	probe_devices();
-}
-
-/**
- * Shut down Etherboot
- *
- * Call this function only once, before either exiting main() or
- * starting up a non-returnable image.
- */
-void shutdown ( void ) {
-	remove_devices();
-	call_exit_fns();
-	unhide_etherboot();
-}
-
 /**
  * Main entry point
  *
  */
 int main ( void ) {
 
+	initialise();
 	startup();
 
 	/* Try autobooting if we're not going straight to the shell */

src/core/malloc.c

 #include <strings.h>
 #include <io.h>
 #include <gpxe/list.h>
+#include <gpxe/init.h>
 #include <gpxe/malloc.h>
 
 /** @file
 /** Total amount of free memory */
 size_t freemem;
 
+/**
+ * Heap size
+ *
+ * Currently fixed at 128kB.
+ */
+#define HEAP_SIZE ( 128 * 1024 )
+
+/** The heap itself */
+static char heap[HEAP_SIZE] __attribute__ (( aligned ( __alignof__(void *) )));
+
 /**
  * Allocate a memory block
  *
 	free_memblock ( start, ( len & ~( MIN_MEMBLOCK_SIZE - 1 ) ) );
 }
 
+/**
+ * Initialise the heap
+ *
+ */
+static void init_heap ( void ) {
+	mpopulate ( heap, sizeof ( heap ) );
+}
+
+/** Memory allocator initialisation function */
+struct init_fn heap_init_fn __init_fn ( INIT_EARLY ) = {
+	.initialise = init_heap,
+};
+
 #if 0
 #include <stdio.h>
 /**

src/core/process.c

  */
 
 #include <gpxe/list.h>
+#include <gpxe/init.h>
 #include <gpxe/process.h>
 
 /** @file
  * Initialise processes
  *
  */
-void init_processes ( void ) {
+static void init_processes ( void ) {
 	struct process *process;
 
 	for ( process = processes ; process < processes_end ; process++ ) {
 		process_add ( process );
 	}
 }
+
+/** Process initialiser */
+struct init_fn process_init_fn __init_fn ( INIT_NORMAL ) = {
+	.initialise = init_processes,
+};

src/core/serial.c

 /*
  * void serial_fini(void);
  *	Cleanup our use of the serial port, in particular flush the
- *	output buffer so we don't accidentially loose characters.
+ *	output buffer so we don't accidentially lose characters.
  */
 static void serial_fini ( void ) {
 	int i, status;
 	.disabled = 1,
 };
 
-INIT_FN ( INIT_CONSOLE, serial_init, serial_fini );
+/** Serial console startup function */
+struct startup_fn serial_startup_fn __startup_fn ( STARTUP_NORMAL ) = {
+	.startup = serial_init,
+	.shutdown = serial_fini,
+};
 
+/**
+ * Serial console initialisation function
+ *
+ * Initialise console early on so that it is available to capture
+ * early debug messages.  It is safe to call serial_init() multiple
+ * times.
+ */
+struct init_fn serial_init_fn __init_fn ( INIT_EARLY ) = {
+	.initialise = serial_init,
+};

src/include/console.h

  * Must be made part of the console drivers table by using
  * #__console_driver.
  *
- * @note Consoles that cannot be used before their INIT_FN() has
- * completed should set #disabled=1 initially.  This allows other
- * console devices to still be used to print out early debugging
- * messages.
+ * @note Consoles that cannot be used before their initialisation
+ * function has completed should set #disabled=1 initially.  This
+ * allows other console devices to still be used to print out early
+ * debugging messages.
  *
  */
 struct console_driver {
 	/** Console is disabled.
 	 *
 	 * The console's putchar(), putline(), getchar() and iskey()
-	 * methods will not be called while #disabled==1. Typically the
-	 * console's initialisation functions (called via INIT_FN())
-	 * will set #disabled=0 upon completion.
+	 * methods will not be called while #disabled==1. Typically
+	 * the console's initialisation functions will set #disabled=0
+	 * upon completion.
 	 *
 	 */
 	int disabled;

src/include/gpxe/heap.h

-#ifndef _GPXE_HEAP_H
-#define _GPXE_HEAP_H
-
-/**
- * @file
- *
- * Heap
- *
- */
-
-extern char heap[];
-
-extern void init_heap ( void );
-
-#endif /* _GPXE_HEAP_H */

src/include/gpxe/hidemem.h

 	EXTMEM,
 };
 
-extern void hide_etherboot();
-extern void unhide_etherboot();
 extern void hide_region ( unsigned int region_id, physaddr_t start,
 			  physaddr_t end );
 

src/include/gpxe/init.h

 
 #include <gpxe/tables.h>
 
-/*
- * In order to avoid having objects dragged in just because main()
- * calls their initialisation function, we allow each object to
- * specify that it has a function that must be called to initialise
- * that object.  The function call_init_fns() will call all the
- * included objects' initialisation functions.
+/**
+ * An initialisation function
  *
- * Objects that require initialisation should include init.h and
- * register the initialisation function using INIT_FN().
+ * Initialisation functions are called exactly once, as part of the
+ * call to initialise().
+ */
+struct init_fn {
+	void ( * initialise ) ( void );
+};
+
+/** Declare an initialisation functon */
+#define __init_fn( init_order ) \
+	__table ( struct init_fn, init_fns, init_order )
+
+/** @defgroup initfn_order Initialisation function ordering
+ * @{
+ */
+
+#define INIT_EARLY	01	/**< Early initialisation */
+#define INIT_NORMAL	02	/**< Normal initialisation */
+
+/** @} */
+
+/**
+ * A startup/shutdown function
  *
- * Objects may register up to three functions: init, reset and exit.
- * init gets called only once, at the point that Etherboot is
- * initialised (before the call to main()).  reset gets called between
- * each boot attempt.  exit gets called only once, just before the
- * loaded OS starts up (or just before Etherboot exits, if it exits,
- * or when the PXE NBP calls UNDI_SHUTDOWN, if it's a PXE NBP).
+ * Startup and shutdown functions may be called multiple times, as
+ * part of the calls to startup() and shutdown().
+ */
+struct startup_fn {
+	void ( * startup ) ( void );
+	void ( * shutdown ) ( void );
+};
+
+/** Declare a startup/shutdown function */
+#define __startup_fn( startup_order ) \
+	__table ( struct startup_fn, startup_fns, startup_order )
+
+/** @defgroup startfn_order Startup/shutdown function ordering
+ *
+ * Shutdown functions are called in the reverse order to startup
+ * functions.
  *
- * The syntax is:
- *   INIT_FN ( init_order, init_function, reset_function, exit_function );
- * where init_order is an ordering taken from the list below.  Any
- * function may be left as NULL.
+ * @{
  */
 
-/* An entry in the initialisation function table */
+#define STARTUP_EARLY	01	/**< Early startup */
+#define STARTUP_NORMAL	02	/**< Normal startup */
 
-struct init_fn {
-	void ( *init ) ( void );
-	void ( *exit ) ( void );
-};
+/** @} */
 
 /* Use double digits to avoid problems with "10" < "9" on alphabetic sort */
 #define	INIT_CONSOLE	02
 #define	INIT_TIMERS	05
 #define	INIT_LOADBUF	08
 #define	INIT_PCMCIA	09
-#define	INIT_RPC	11
-
-/* Macro for creating an initialisation function table entry */
-#define INIT_FN( init_order, init_func, exit_func )	\
-	struct init_fn PREFIX_OBJECT(init_fn__)			\
-	    __table ( struct init_fn, init_fn, init_order ) = {	\
-		.init = init_func,				\
-		.exit = exit_func,				\
-	};
-
-/* Function prototypes */
 
-void call_init_fns ( void );
-void call_exit_fns ( void );
+extern void initialise ( void );
+extern void startup ( void );
+extern void shutdown ( void );
 
 #endif /* _GPXE_INIT_H */

src/include/gpxe/process.h

 extern void process_add ( struct process *process );
 extern void process_del ( struct process *process );
 extern void step ( void );
-extern void init_processes ( void );
 
 /**
  * Initialise process without adding to process list

src/include/gpxe/shutdown.h

-#ifndef _GPXE_SHUTDOWN_H
-#define _GPXE_SHUTDOWN_H
-
-/**
- * Shut down before exit
- */
-
-extern void shutdown ( void );
-
-#endif /* _GPXE_SHUTDOWN_H */

src/interface/pxe/pxe_preboot.c

 #include <gpxe/device.h>
 #include <gpxe/netdevice.h>
 #include <gpxe/isapnp.h>
+#include <gpxe/init.h>
 #include <basemem_packet.h>
 #include "pxe.h"
 #include "pxe_call.h"
 PXENV_EXIT_t pxenv_unload_stack ( struct s_PXENV_UNLOAD_STACK *unload_stack ) {
 	DBG ( "PXENV_UNLOAD_STACK" );
 
-#if 0
-	/* We need to call cleanup() at some point.  The network card
-	 * has already been disabled by ENSURE_CAN_UNLOAD(), but for
-	 * the sake of completeness we should call the console_fini()
-	 * etc. that are part of cleanup().
-	 *
-	 * There seems to be a lack of consensus on which is the final
-	 * PXE API call to make, but it's a fairly safe bet that all
-	 * the potential shutdown sequences will include a call to
-	 * PXENV_UNLOAD_STACK at some point, so we may as well do it
-	 * here.
-	 */
-	cleanup();
-
-	if ( ! success ) {
-		unload_stack->Status = PXENV_STATUS_KEEP_ALL;
-		return PXENV_EXIT_FAILURE;
-	}
-#endif
-
 	unload_stack->Status = PXENV_STATUS_SUCCESS;
 	return PXENV_EXIT_SUCCESS;
 }
 	DBG ( "PXENV_START_UNDI %04x:%04x:%04x",
 	      start_undi->AX, start_undi->BX, start_undi->DX );
 
+	/* Probe for devices, etc. */
+	startup();
+
 	/* Determine bus type and location */
 	isapnp_read_port = start_undi->DX;
 	isapnp_csn = start_undi->BX;
 PXENV_EXIT_t pxenv_stop_undi ( struct s_PXENV_STOP_UNDI *stop_undi ) {
 	DBG ( "PXENV_STOP_UNDI" );
 
-#if 0
-	if ( ! ensure_pxe_state(CAN_UNLOAD) ) {
-		stop_undi->Status = PXENV_STATUS_KEEP_UNDI;
-		return PXENV_EXIT_FAILURE;
-	}
-#endif
+	/* Unhook INT 1A */
+	pxe_unhook_int1a();
+
+	/* Clear PXE net device */
+	pxe_set_netdev ( NULL );
+
+	/* Prepare for unload */
+	shutdown();
 
 	stop_undi->Status = PXENV_STATUS_SUCCESS;
 	return PXENV_EXIT_SUCCESS;

src/proto/nfs.c

 /**************************************************************************
 RPC_INIT - set up the ID counter to something fairly random
 **************************************************************************/
-static void rpc_init(void)
+void rpc_init(void)
 {
 	unsigned long t;
 
 	return 1;
 }
 
-INIT_FN ( INIT_RPC, rpc_init, nfs_reset );
-
 struct protocol nfs_protocol __protocol = {
 	.name = "nfs",
 	.default_port = SUNRPC_PORT,