[interface] Convert all job-control interfaces to generic interfaces

Remove job-control as an interface type, and replace job-control
interfaces with generic interfaces supporting the close() method.
(Both done() and kill() are absorbed into the function of close();
kill() is merely close(-ECANCELED).)

Signed-off-by: Michael Brown <mcb30@ipxe.org>

src/core/downloader.c

 	struct refcnt refcnt;
 
 	/** Job control interface */
-	struct job_interface job;
+	struct interface job;
 	/** Data transfer interface */
 	struct xfer_interface xfer;
 
  */
 static void downloader_finished ( struct downloader *downloader, int rc ) {
 
-	/* Block further incoming messages */
-	job_nullify ( &downloader->job );
-	xfer_nullify ( &downloader->xfer );
+	/* Register image if download was successful */
+	if ( rc == 0 )
+		rc = downloader->register_image ( downloader->image );
 
-	/* Free resources and close interfaces */
+	/* Shut down interfaces */
+	xfer_nullify ( &downloader->xfer );
 	xfer_close ( &downloader->xfer, rc );
-	job_done ( &downloader->job, rc );
+	intf_shutdown ( &downloader->job, rc );
 }
 
 /**
  *
  */
 
-/**
- * Handle kill() event received via job control interface
- *
- * @v job		Downloader job control interface
- */
-static void downloader_job_kill ( struct job_interface *job ) {
-	struct downloader *downloader =
-		container_of ( job, struct downloader, job );
-
-	/* Terminate download */
-	downloader_finished ( downloader, -ECANCELED );
-}
-
 /**
  * Report progress of download job
  *
- * @v job		Downloader job control interface
+ * @v downloader	Downloader
  * @v progress		Progress report to fill in
  */
-static void downloader_job_progress ( struct job_interface *job,
-				      struct job_progress *progress ) {
-	struct downloader *downloader =
-		container_of ( job, struct downloader, job );
+static void downloader_progress ( struct downloader *downloader,
+				  struct job_progress *progress ) {
 
 	/* This is not entirely accurate, since downloaded data may
 	 * arrive out of order (e.g. with multicast protocols), but
 	progress->total = downloader->image->len;
 }
 
-/** Downloader job control interface operations */
-static struct job_interface_operations downloader_job_operations = {
-	.done		= ignore_job_done,
-	.kill		= downloader_job_kill,
-	.progress	= downloader_job_progress,
-};
-
 /****************************************************************************
  *
  * Data transfer interface
 	struct downloader *downloader =
 		container_of ( xfer, struct downloader, xfer );
 
-	/* Register image if download was successful */
-	if ( rc == 0 )
-		rc = downloader->register_image ( downloader->image );
-
 	/* Terminate download */
 	downloader_finished ( downloader, rc );
 }
 	.deliver_raw	= xfer_deliver_as_iob,
 };
 
+/****************************************************************************
+ *
+ * Job control interface
+ *
+ */
+
+/** Downloader job control interface operations */
+static struct interface_operation downloader_job_op[] = {
+	INTF_OP ( job_progress, struct downloader *, downloader_progress ),
+	INTF_OP ( intf_close, struct downloader *, downloader_finished ),
+};
+
+/** Downloader job control interface descriptor */
+static struct interface_descriptor downloader_job_desc =
+	INTF_DESC ( struct downloader, job, downloader_job_op );
+
 /****************************************************************************
  *
  * Instantiator
  * the specified image object.  If the download is successful, the
  * image registration routine @c register_image() will be called.
  */
-int create_downloader ( struct job_interface *job, struct image *image,
+int create_downloader ( struct interface *job, struct image *image,
 			int ( * register_image ) ( struct image *image ),
 			int type, ... ) {
 	struct downloader *downloader;
 	if ( ! downloader )
 		return -ENOMEM;
 	ref_init ( &downloader->refcnt, downloader_free );
-	job_init ( &downloader->job, &downloader_job_operations,
-		   &downloader->refcnt );
+	intf_init ( &downloader->job, &downloader_job_desc,
+		    &downloader->refcnt );
 	xfer_init ( &downloader->xfer, &downloader_xfer_operations,
 		    &downloader->refcnt );
 	downloader->image = image_get ( image );
 		goto err;
 
 	/* Attach parent interface, mortalise self, and return */
-	job_plug_plug ( &downloader->job, job );
+	intf_plug_plug ( &downloader->job, job );
 	ref_put ( &downloader->refcnt );
 	va_end ( args );
 	return 0;

src/core/job.c

  *
  */
 
-void job_done ( struct job_interface *job, int rc ) {
-	struct job_interface *dest = job_get_dest ( job );
-
-	job_unplug ( job );
-	dest->op->done ( dest, rc );
-	job_put ( dest );
-}
-
-void job_kill ( struct job_interface *job ) {
-	struct job_interface *dest = job_get_dest ( job );
-
-	job_unplug ( job );
-	dest->op->kill ( dest );
-	job_put ( dest );
-}
-
-void job_progress ( struct job_interface *job,
-		    struct job_progress *progress ) {
-	struct job_interface *dest = job_get_dest ( job );
-
-	dest->op->progress ( dest, progress );
-	job_put ( dest );
-}
-
-/****************************************************************************
- *
- * Helper methods
- *
- * These functions are designed to be used as methods in the
- * job_interface_operations table.
- *
- */
-
-void ignore_job_done ( struct job_interface *job __unused, int rc __unused ) {
-	/* Nothing to do */
-}
-
-void ignore_job_kill ( struct job_interface *job __unused ) {
-	/* Nothing to do */
-}
-
-void ignore_job_progress ( struct job_interface *job __unused,
-			   struct job_progress *progress ) {
-	memset ( progress, 0, sizeof ( *progress ) );
-}
-
-/** Null job control interface operations */
-struct job_interface_operations null_job_ops = {
-	.done		= ignore_job_done,
-	.kill		= ignore_job_kill,
-	.progress	= ignore_job_progress,
-};
-
 /**
- * Null job control interface
+ * Get job progress
  *
- * This is the interface to which job control interfaces are connected
- * when unplugged.  It will never generate messages, and will silently
- * absorb all received messages.
+ * @v intf		Object interface
+ * @v progress		Progress data to fill in
  */
-struct job_interface null_job = {
-	.intf = {
-		.dest = &null_job.intf,
-		.refcnt = NULL,
-	},
-	.op = &null_job_ops,
-};
+void job_progress ( struct interface *intf, struct job_progress *progress ) {
+	struct interface *dest;
+	job_progress_TYPE ( void * ) *op =
+		intf_get_dest_op ( intf, job_progress, &dest );
+	void *object = intf_object ( dest );
+
+	DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " job_progress\n",
+	       INTF_INTF_DBG ( intf, dest ) );
+
+	if ( op ) {
+		op ( object, progress );
+	} else {
+		/* Default is to mark progress as zero */
+		memset ( progress, 0, sizeof ( *progress ) );
+	}
+
+	intf_put ( dest );
+}

src/core/monojob.c

 
 static int monojob_rc;
 
-static void monojob_done ( struct job_interface *job __unused, int rc ) {
+static void monojob_close ( struct interface *intf, int rc ) {
 	monojob_rc = rc;
+	intf_restart ( intf, rc );
 }
 
-/** Single foreground job operations */
-static struct job_interface_operations monojob_operations = {
-	.done		= monojob_done,
-	.kill		= ignore_job_kill,
-	.progress	= ignore_job_progress,
+static struct interface_operation monojob_intf_op[] = {
+	INTF_OP ( intf_close, struct interface *, monojob_close ),
 };
 
-/** Single foreground job */
-struct job_interface monojob = {
-	.intf = {
-		.dest = &null_job.intf,
-		.refcnt = NULL,
-	},
-	.op = &monojob_operations,
-};
+static struct interface_descriptor monojob_intf_desc =
+	INTF_DESC_PURE ( monojob_intf_op );
+
+struct interface monojob = INTF_INIT ( monojob_intf_desc );
 
 /**
  * Wait for single foreground job to complete
 			key = getchar();
 			switch ( key ) {
 			case CTRL_C:
-				job_kill ( &monojob );
-				rc = -ECANCELED;
-				goto done;
+				monojob_close ( &monojob, -ECANCELED );
+				break;
 			default:
 				break;
 			}
 	}
 	rc = monojob_rc;
 
-done:
-	job_done ( &monojob, rc );
 	if ( rc ) {
 		printf ( " %s\n", strerror ( rc ) );
 	} else {

src/include/ipxe/dhcp.h

 #include <ipxe/netdevice.h>
 #include <ipxe/uaccess.h>
 
-struct job_interface;
+struct interface;
 struct dhcp_options;
 struct dhcp_packet;
 
 				 struct net_device *netdev,
 				 unsigned int msgtype, struct in_addr ciaddr,
 				 void *data, size_t max_len );
-extern int start_dhcp ( struct job_interface *job, struct net_device *netdev );
-extern int start_pxebs ( struct job_interface *job, struct net_device *netdev,
+extern int start_dhcp ( struct interface *job, struct net_device *netdev );
+extern int start_pxebs ( struct interface *job, struct net_device *netdev,
 			 unsigned int pxe_type );
 
 /* In environments that can provide cached DHCP packets, this function

src/include/ipxe/downloader.h

 
 FILE_LICENCE ( GPL2_OR_LATER );
 
-struct job_interface;
+struct interface;
 struct image;
 
-extern int create_downloader ( struct job_interface *job, struct image *image,
+extern int create_downloader ( struct interface *job, struct image *image,
 			       int ( * register_image ) ( struct image *image ),
 			       int type, ... );
 

src/include/ipxe/job.h

 
 FILE_LICENCE ( GPL2_OR_LATER );
 
-#include <stddef.h>
 #include <ipxe/interface.h>
 
 /** Job progress */
 	unsigned long total;
 };
 
-struct job_interface;
-
-/** Job control interface operations */
-struct job_interface_operations {
-	/** Job completed
-	 *
-	 * @v job		Job control interface
-	 * @v rc		Overall job status code
-	 */
-	void ( * done ) ( struct job_interface *job, int rc );
-	/** Abort job
-	 *
-	 * @v job		Job control interface
-	 */
-	void ( * kill ) ( struct job_interface *job );
-	/** Get job progress
-	 *
-	 * @v job		Job control interface
-	 * @v progress		Progress data to fill in
-	 */
-	void ( * progress ) ( struct job_interface *job,
-			      struct job_progress *progress );
-};
-
-/** A job control interface */
-struct job_interface {
-	/** Generic object communication interface */
-	struct interface intf;
-	/** Operations for received messages */
-	struct job_interface_operations *op;
-};
-
-extern struct job_interface null_job;
-extern struct job_interface_operations null_job_ops;
-
-extern void job_done ( struct job_interface *job, int rc );
-extern void job_kill ( struct job_interface *job );
-extern void job_progress ( struct job_interface *job,
+extern void job_progress ( struct interface *intf,
 			   struct job_progress *progress );
-
-extern void ignore_job_done ( struct job_interface *job, int rc );
-extern void ignore_job_kill ( struct job_interface *job );
-extern void ignore_job_progress ( struct job_interface *job,
-				  struct job_progress *progress );
-
-/**
- * Initialise a job control interface
- *
- * @v job		Job control interface
- * @v op		Job control interface operations
- * @v refcnt		Containing object reference counter, or NULL
- */
-static inline void job_init ( struct job_interface *job,
-			      struct job_interface_operations *op,
-			      struct refcnt *refcnt ) {
-	job->intf.dest = &null_job.intf;
-	job->intf.refcnt = refcnt;
-	job->op = op;
-}
-
-/**
- * Get job control interface from generic object communication interface
- *
- * @v intf		Generic object communication interface
- * @ret job		Job control interface
- */
-static inline __attribute__ (( always_inline )) struct job_interface *
-intf_to_job ( struct interface *intf ) {
-	return container_of ( intf, struct job_interface, intf );
-}
-
-/**
- * Get reference to destination job control interface
- *
- * @v job		Job control interface
- * @ret dest		Destination interface
- */
-static inline __attribute__ (( always_inline )) struct job_interface *
-job_get_dest ( struct job_interface *job ) {
-	return intf_to_job ( intf_get ( job->intf.dest ) );
-}
-
-/**
- * Drop reference to job control interface
- *
- * @v job		Job control interface
- */
-static inline __attribute__ (( always_inline )) void
-job_put ( struct job_interface *job ) {
-	intf_put ( &job->intf );
-}
-
-/**
- * Plug a job control interface into a new destination interface
- *
- * @v job		Job control interface
- * @v dest		New destination interface
- */
-static inline void job_plug ( struct job_interface *job,
-			       struct job_interface *dest ) {
-	intf_plug ( &job->intf, &dest->intf );
-}
-
-/**
- * Plug two job control interfaces together
- *
- * @v a			Job control interface A
- * @v b			Job control interface B
- */
-static inline void job_plug_plug ( struct job_interface *a,
-				    struct job_interface *b ) {
-	intf_plug_plug ( &a->intf, &b->intf );
-}
-
-/**
- * Unplug a job control interface
- *
- * @v job		Job control interface
- */
-static inline void job_unplug ( struct job_interface *job ) {
-	intf_plug ( &job->intf, &null_job.intf );
-}
-
-/**
- * Stop using a job control interface
- *
- * @v job		Job control interface
- *
- * After calling this method, no further messages will be received via
- * the interface.
- */
-static inline void job_nullify ( struct job_interface *job ) {
-	job->op = &null_job_ops;
-};
+#define job_progress_TYPE( object_type ) \
+	typeof ( void ( object_type, struct job_progress *progress ) )
 
 #endif /* _IPXE_JOB_H */

src/include/ipxe/monojob.h

 
 FILE_LICENCE ( GPL2_OR_LATER );
 
-struct job_interface;
+struct interface;
+
+extern struct interface monojob;
 
-extern struct job_interface monojob;
 extern int monojob_wait ( const char *string );
 
 #endif /* _IPXE_MONOJOB_H */

src/net/udp/dhcp.c

 	/** Reference counter */
 	struct refcnt refcnt;
 	/** Job control interface */
-	struct job_interface job;
+	struct interface job;
 	/** Data transfer interface */
 	struct xfer_interface xfer;
 
  */
 static void dhcp_finished ( struct dhcp_session *dhcp, int rc ) {
 
-	/* Block futher incoming messages */
-	job_nullify ( &dhcp->job );
-	xfer_nullify ( &dhcp->xfer );
-
 	/* Stop retry timer */
 	stop_timer ( &dhcp->timer );
 
-	/* Free resources and close interfaces */
+	/* Shut down interfaces */
+	xfer_nullify ( &dhcp->xfer );
 	xfer_close ( &dhcp->xfer, rc );
-	job_done ( &dhcp->job, rc );
+	intf_shutdown ( &dhcp->job, rc );
 }
 
 /**
  *
  */
 
-/**
- * Handle kill() event received via job control interface
- *
- * @v job		DHCP job control interface
- */
-static void dhcp_job_kill ( struct job_interface *job ) {
-	struct dhcp_session *dhcp =
-		container_of ( job, struct dhcp_session, job );
-
-	/* Terminate DHCP session */
-	dhcp_finished ( dhcp, -ECANCELED );
-}
-
 /** DHCP job control interface operations */
-static struct job_interface_operations dhcp_job_operations = {
-	.done		= ignore_job_done,
-	.kill		= dhcp_job_kill,
-	.progress	= ignore_job_progress,
+static struct interface_operation dhcp_job_op[] = {
+	INTF_OP ( intf_close, struct dhcp_session *, dhcp_finished ),
 };
 
+/** DHCP job control interface descriptor */
+static struct interface_descriptor dhcp_job_desc =
+	INTF_DESC ( struct dhcp_session, job, dhcp_job_op );
+
 /****************************************************************************
  *
  * Instantiators
  * started; a positive return value indicates the success condition of
  * having fetched the appropriate data from cached information.
  */
-int start_dhcp ( struct job_interface *job, struct net_device *netdev ) {
+int start_dhcp ( struct interface *job, struct net_device *netdev ) {
 	struct dhcp_session *dhcp;
 	int rc;
 
 	if ( ! dhcp )
 		return -ENOMEM;
 	ref_init ( &dhcp->refcnt, dhcp_free );
-	job_init ( &dhcp->job, &dhcp_job_operations, &dhcp->refcnt );
+	intf_init ( &dhcp->job, &dhcp_job_desc, &dhcp->refcnt );
 	xfer_init ( &dhcp->xfer, &dhcp_xfer_operations, &dhcp->refcnt );
 	timer_init ( &dhcp->timer, dhcp_timer_expired );
 	dhcp->netdev = netdev_get ( netdev );
 	dhcp_set_state ( dhcp, &dhcp_state_discover );
 
 	/* Attach parent interface, mortalise self, and return */
-	job_plug_plug ( &dhcp->job, job );
+	intf_plug_plug ( &dhcp->job, job );
 	ref_put ( &dhcp->refcnt );
 	return 0;
 
  * If successful, the Boot Server ACK will be registered as an option
  * source.
  */
-int start_pxebs ( struct job_interface *job, struct net_device *netdev,
+int start_pxebs ( struct interface *job, struct net_device *netdev,
 		  unsigned int pxe_type ) {
 	struct setting pxe_discovery_control_setting =
 		{ .tag = DHCP_PXE_DISCOVERY_CONTROL };
 	if ( ! dhcp )
 		return -ENOMEM;
 	ref_init ( &dhcp->refcnt, dhcp_free );
-	job_init ( &dhcp->job, &dhcp_job_operations, &dhcp->refcnt );
+	intf_init ( &dhcp->job, &dhcp_job_desc, &dhcp->refcnt );
 	xfer_init ( &dhcp->xfer, &dhcp_xfer_operations, &dhcp->refcnt );
 	timer_init ( &dhcp->timer, dhcp_timer_expired );
 	dhcp->netdev = netdev_get ( netdev );
 	dhcp_set_state ( dhcp, &dhcp_state_pxebs );
 
 	/* Attach parent interface, mortalise self, and return */
-	job_plug_plug ( &dhcp->job, job );
+	intf_plug_plug ( &dhcp->job, job );
 	ref_put ( &dhcp->refcnt );
 	return 0;