[refcnt] Add ref_init() wrapper function

Standardise on using ref_init() to initialise an embedded reference
count, to match the coding style used by other embedded objects.

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

src/core/downloader.c

 	downloader = zalloc ( sizeof ( *downloader ) );
 	if ( ! downloader )
 		return -ENOMEM;
-	downloader->refcnt.free = downloader_free;
+	ref_init ( &downloader->refcnt, downloader_free );
 	job_init ( &downloader->job, &downloader_job_operations,
 		   &downloader->refcnt );
 	xfer_init ( &downloader->xfer, &downloader_xfer_operations,

src/core/hw.c

 	hw = zalloc ( sizeof ( *hw ) );
 	if ( ! hw )
 		return -ENOMEM;
+	ref_init ( &hw->refcnt, NULL );
 	xfer_init ( &hw->xfer, &hw_xfer_operations, &hw->refcnt );
 	process_init ( &hw->process, hw_step, &hw->refcnt );
 

src/core/image.c

 
 	image = zalloc ( sizeof ( *image ) );
 	if ( image ) {
-		image->refcnt.free = free_image;
+		ref_init ( &image->refcnt, free_image );
 	}
 	return image;
 }

src/core/posix_io.c

 	file = zalloc ( sizeof ( *file ) );
 	if ( ! file )
 		return -ENOMEM;
-	file->refcnt.free = posix_file_free;
+	ref_init ( &file->refcnt, posix_file_free );
 	file->fd = fd;
 	file->rc = -EINPROGRESS;
 	xfer_init ( &file->xfer, &posix_file_xfer_operations,

src/core/resolv.c

 	numeric = zalloc ( sizeof ( *numeric ) );
 	if ( ! numeric )
 		return -ENOMEM;
+	ref_init ( &numeric->refcnt, NULL );
 	resolv_init ( &numeric->resolv, &null_resolv_ops, &numeric->refcnt );
 	process_init ( &numeric->process, numeric_step, &numeric->refcnt );
 	memcpy ( &numeric->sa, sa, sizeof ( numeric->sa ) );
 	mux = zalloc ( sizeof ( *mux ) + name_len );
 	if ( ! mux )
 		return -ENOMEM;
+	ref_init ( &mux->refcnt, NULL );
 	resolv_init ( &mux->parent, &null_resolv_ops, &mux->refcnt );
 	resolv_init ( &mux->child, &resolv_mux_child_ops, &mux->refcnt );
 	mux->resolver = table_start ( RESOLVERS );
 	named = zalloc ( sizeof ( *named ) );
 	if ( ! named )
 		return -ENOMEM;
+	ref_init ( &named->refcnt, NULL );
 	xfer_init ( &named->xfer, &named_xfer_ops, &named->refcnt );
 	resolv_init ( &named->resolv, &named_resolv_ops, &named->refcnt );
 	named->semantics = semantics;

src/drivers/block/srp.c

 		rc = -ENOMEM;
 		goto err_alloc;
 	}
+	ref_init ( &srp->refcnt, NULL );
 	xfer_init ( &srp->socket, &srp_xfer_operations, &srp->refcnt );
 	srp->transport = transport;
 	DBGC ( srp, "SRP %p using %s\n", srp, root_path );

src/image/embedded.c

 /* Image structures for all embedded images */
 #undef EMBED
 #define EMBED( _index, _path, _name ) {					\
-	.refcnt = { .free = embedded_image_free, },			\
+	.refcnt = REF_INIT ( embedded_image_free ),			\
 	.name = _name,							\
 	.data = ( userptr_t ) ( embedded_image_ ## _index ## _data ),	\
 	.len = ( size_t ) embedded_image_ ## _index ## _len,		\

src/include/ipxe/refcnt.h

 	void ( * free ) ( struct refcnt *refcnt );
 };
 
+/**
+ * Initialise a reference counter
+ *
+ * @v refcnt		Reference counter
+ * @v free		Freeing function
+ */
+static inline __attribute__ (( always_inline )) void
+ref_init ( struct refcnt *refcnt,
+	   void ( * free ) ( struct refcnt *refcnt ) ) {
+	refcnt->free = free;
+}
+
+/**
+ * Initialise a reference counter
+ *
+ * @v refcnt		Reference counter
+ * @v free		Free containing object
+ */
+#define ref_init( refcnt, free ) do {					\
+	if ( __builtin_constant_p ( (free) ) && ( (free) == NULL ) ) {	\
+		/* Skip common case of no initialisation required */	\
+	} else {							\
+		ref_init ( (refcnt), (free) );				\
+	}								\
+	} while ( 0 )
+
+/**
+ * Initialise a static reference counter
+ *
+ * @v free		Free containing object
+ */
+#define REF_INIT( free ) {						\
+		.free = free,						\
+	}
+
 extern struct refcnt * ref_get ( struct refcnt *refcnt );
 extern void ref_put ( struct refcnt *refcnt );
 

src/net/aoe.c

 	aoe = zalloc ( sizeof ( *aoe ) );
 	if ( ! aoe )
 		return -ENOMEM;
-	aoe->refcnt.free = aoe_free;
+	ref_init ( &aoe->refcnt, aoe_free );
 	aoe->netdev = netdev_get ( netdev );
 	memcpy ( aoe->target, netdev->ll_broadcast, sizeof ( aoe->target ) );
 	aoe->tag = AOE_TAG_MAGIC;

src/net/dhcppkt.c

  */
 void dhcppkt_init ( struct dhcp_packet *dhcppkt, struct dhcphdr *data,
 		    size_t len ) {
+	ref_init ( &dhcppkt->refcnt, NULL );
 	dhcppkt->dhcphdr = data;
 	dhcppkt->max_len = len;
 	dhcpopt_init ( &dhcppkt->options, &dhcppkt->dhcphdr->options,

src/net/infiniband/ib_cmrc.c

 		rc = -ENOMEM;
 		goto err_alloc;
 	}
+	ref_init ( &cmrc->refcnt, NULL );
 	xfer_init ( &cmrc->xfer, &ib_cmrc_xfer_operations, &cmrc->refcnt );
 	cmrc->ibdev = ibdev;
 	memcpy ( &cmrc->dgid, dgid, sizeof ( cmrc->dgid ) );

src/net/netdevice.c

 	total_len = ( sizeof ( *netdev ) + priv_size );
 	netdev = zalloc ( total_len );
 	if ( netdev ) {
-		netdev->refcnt.free = free_netdev;
+		ref_init ( &netdev->refcnt, free_netdev );
 		netdev->link_rc = -EUNKNOWN_LINK_STATUS;
 		INIT_LIST_HEAD ( &netdev->tx_queue );
 		INIT_LIST_HEAD ( &netdev->rx_queue );

src/net/tcp.c

 	if ( ! tcp )
 		return -ENOMEM;
 	DBGC ( tcp, "TCP %p allocated\n", tcp );
+	ref_init ( &tcp->refcnt, NULL );
 	xfer_init ( &tcp->xfer, &tcp_xfer_operations, &tcp->refcnt );
 	tcp->prev_tcp_state = TCP_CLOSED;
 	tcp->tcp_state = TCP_STATE_SENT ( TCP_SYN );

src/net/tcp/ftp.c

 	ftp = zalloc ( sizeof ( *ftp ) );
 	if ( ! ftp )
 		return -ENOMEM;
-	ftp->refcnt.free = ftp_free;
+	ref_init ( &ftp->refcnt, ftp_free );
 	xfer_init ( &ftp->xfer, &ftp_xfer_operations, &ftp->refcnt );
 	ftp->uri = uri_get ( uri );
 	xfer_init ( &ftp->control, &ftp_control_operations, &ftp->refcnt );

src/net/tcp/http.c

 	http = zalloc ( sizeof ( *http ) );
 	if ( ! http )
 		return -ENOMEM;
-	http->refcnt.free = http_free;
+	ref_init ( &http->refcnt, http_free );
 	xfer_init ( &http->xfer, &http_xfer_operations, &http->refcnt );
        	http->uri = uri_get ( uri );
 	xfer_init ( &http->socket, &http_socket_operations, &http->refcnt );

src/net/tcp/iscsi.c

 	iscsi = zalloc ( sizeof ( *iscsi ) );
 	if ( ! iscsi )
 		return -ENOMEM;
-	iscsi->refcnt.free = iscsi_free;
+	ref_init ( &iscsi->refcnt, iscsi_free );
 	xfer_init ( &iscsi->socket, &iscsi_socket_operations, &iscsi->refcnt );
 	process_init ( &iscsi->process, iscsi_tx_step, &iscsi->refcnt );
 

src/net/tls.c

 	if ( ! tls )
 		return -ENOMEM;
 	memset ( tls, 0, sizeof ( *tls ) );
-	tls->refcnt.free = free_tls;
+	ref_init ( &tls->refcnt, free_tls );
 	filter_init ( &tls->plainstream, &tls_plainstream_operations,
 		      &tls->cipherstream, &tls_cipherstream_operations,
 		      &tls->refcnt );

src/net/udp.c

 	if ( ! udp )
 		return -ENOMEM;
 	DBGC ( udp, "UDP %p allocated\n", udp );
+	ref_init ( &udp->refcnt, NULL );
 	xfer_init ( &udp->xfer, &udp_xfer_operations, &udp->refcnt );
 	if ( st_peer )
 		memcpy ( &udp->peer, st_peer, sizeof ( udp->peer ) );

src/net/udp/dhcp.c

 	dhcp = zalloc ( sizeof ( *dhcp ) );
 	if ( ! dhcp )
 		return -ENOMEM;
-	dhcp->refcnt.free = dhcp_free;
+	ref_init ( &dhcp->refcnt, dhcp_free );
 	job_init ( &dhcp->job, &dhcp_job_operations, &dhcp->refcnt );
 	xfer_init ( &dhcp->xfer, &dhcp_xfer_operations, &dhcp->refcnt );
 	dhcp->netdev = netdev_get ( netdev );
 			sizeof ( *ip ) /* terminator */ );
 	if ( ! dhcp )
 		return -ENOMEM;
-	dhcp->refcnt.free = dhcp_free;
+	ref_init ( &dhcp->refcnt, dhcp_free );
 	job_init ( &dhcp->job, &dhcp_job_operations, &dhcp->refcnt );
 	xfer_init ( &dhcp->xfer, &dhcp_xfer_operations, &dhcp->refcnt );
 	dhcp->netdev = netdev_get ( netdev );

src/net/udp/dns.c

 		rc = -ENOMEM;
 		goto err_alloc_dns;
 	}
+	ref_init ( &dns->refcnt, NULL );
 	resolv_init ( &dns->resolv, &null_resolv_ops, &dns->refcnt );
 	xfer_init ( &dns->socket, &dns_socket_operations, &dns->refcnt );
 	dns->timer.expired = dns_timer_expired;

src/net/udp/slam.c

 	slam = zalloc ( sizeof ( *slam ) );
 	if ( ! slam )
 		return -ENOMEM;
-	slam->refcnt.free = slam_free;
+	ref_init ( &slam->refcnt, slam_free );
 	xfer_init ( &slam->xfer, &slam_xfer_operations, &slam->refcnt );
 	xfer_init ( &slam->socket, &slam_socket_operations, &slam->refcnt );
 	xfer_init ( &slam->mc_socket, &slam_mc_socket_operations,

src/net/udp/tftp.c

 	tftp = zalloc ( sizeof ( *tftp ) );
 	if ( ! tftp )
 		return -ENOMEM;
-	tftp->refcnt.free = tftp_free;
+	ref_init ( &tftp->refcnt, tftp_free );
 	xfer_init ( &tftp->xfer, &tftp_xfer_operations, &tftp->refcnt );
 	tftp->uri = uri_get ( uri );
 	xfer_init ( &tftp->socket, &tftp_socket_operations, &tftp->refcnt );