Begone with the printf variants of the log functions

1 files changed, 49 insertions, 49 deletions

diff --git a/libhw_cr/w5500.c b/libhw_cr/w5500.c
index 2893e8f..6f3f302 100644
--- a/libhw_cr/w5500.c
+++ b/libhw_cr/w5500.c
@@ -79,7 +79,7 @@
 #include <libhw/generic/alarmclock.h> /* for sleep_*() */
 
 #define LOG_NAME W5500
-#include <libmisc/log.h> /* for log_errorf(), log_debugf(), const_byte_str() */
+#include <libmisc/log.h>
 
 #define IMPLEMENTATION_FOR_LIBHW_W5500_H YES
 #include <libhw/w5500.h>
@@ -187,7 +187,7 @@ static COROUTINE w5500_irq_cr(void *_chip) {
 		bool had_intr = false;
 
 		uint8_t chipintr = w5500ll_read_common_reg(chip->spidev, chip_interrupt);
-		log_n_debugf(W5500_LL, "w5500_irq_cr(): chipintr=%"PRIu8, chipintr);
+		log_n_debugln(W5500_LL, "w5500_irq_cr(): chipintr=", chipintr);
 		had_intr = had_intr || (chipintr != 0);
 		if (chipintr)
 			w5500ll_write_common_reg(chip->spidev, chip_interrupt, 0xFF);
@@ -196,7 +196,7 @@ static COROUTINE w5500_irq_cr(void *_chip) {
 			struct _w5500_socket *socket = &chip->sockets[socknum];
 
 			uint8_t sockintr = w5500ll_read_sock_reg(chip->spidev, socknum, interrupt);
-			log_n_debugf(W5500_LL, "w5500_irq_cr(): sockintr[%"PRIu8"]=%"PRIu8, socknum, sockintr);
+			log_n_debugln(W5500_LL, "w5500_irq_cr(): sockintr[", socknum, "]=", sockintr);
 			had_intr = had_intr || (sockintr != 0);
 
 			switch (socket->mode) {
@@ -208,15 +208,15 @@ static COROUTINE w5500_irq_cr(void *_chip) {
 					recv_bits   = sockintr & (SOCKINTR_RECV_DAT|SOCKINTR_RECV_FIN);
 
 				if (listen_bits) {
-					log_debugf("w5500_irq_cr(): signal sock[%"PRIu8"]->listen_sema", socknum);
+					log_debugln("w5500_irq_cr(): signal sock[", socknum, "]->listen_sema");
 					cr_sema_signal(&socket->listen_sema);
 				}
 				if (recv_bits) {
-					log_debugf("w5500_irq_cr(): signal sock[%"PRIu8"]->read_sema", socknum);
+					log_debugln("w5500_irq_cr(): signal sock[", socknum, "]->read_sema");
 					cr_sema_signal(&socket->read_sema);
 				}
 				if (send_bits) {
-					log_debugf("w5500_irq_cr(): signal sock[%"PRIu8"]->write_ch", socknum);
+					log_debugln("w5500_irq_cr(): signal sock[", socknum, "]->write_ch");
 					cr_chan_send(&socket->write_ch, send_bits);
 				}
 				break;
@@ -228,7 +228,7 @@ static COROUTINE w5500_irq_cr(void *_chip) {
 		cr_mutex_unlock(&chip->mu);
 
 		if (!had_intr && gpio_get(chip->pin_intr)) {
-			log_debugf("w5500_irq_cr(): looks like all interrupts have been processed, sleeping...");
+			log_debugln("w5500_irq_cr(): looks like all interrupts have been processed, sleeping...");
 			cr_sema_wait(&chip->intr);
 		} else
 			cr_yield();
@@ -283,7 +283,7 @@ static inline void w5500_socket_close(struct _w5500_socket *socket) {
 
 static void w5500_intrhandler(void *_chip, uint LM_UNUSED(gpio), enum gpio_irq_level LM_UNUSED(event)) {
 	struct w5500 *chip = _chip;
-	log_debugf("w5500_intrhandler()");
+	log_debugln("w5500_intrhandler()");
 	cr_sema_signal_from_intrhandler(&chip->intr);
 }
 
@@ -322,7 +322,7 @@ void _w5500_init(struct w5500 *chip,
 		w5500ll_write_sock_reg(chip->spidev, 0, mode, a);
 		uint8_t b = w5500ll_read_sock_reg(chip->spidev, 0, mode);
 		if (b != a) {
-			log_errorf("SPI to W5500 does not appear to be functional: wrote:0x%02"PRIx16" != read:0x%02"PRIx8, a, b);
+			log_errorln("SPI to W5500 does not appear to be functional: wrote:", (base16_u8_, a), " != read:", (base16_u8_, b));
 			spi_ok = false;
 		}
 	}
@@ -427,15 +427,15 @@ static void _w5500_if_up(struct w5500 *chip, struct net_iface_config cfg) {
 }
 
 static void w5500_if_ifup(struct w5500 *chip, struct net_iface_config cfg) {
-	log_debugf("if_up()");
-	log_debugf(":: addr         = "PRI_net_ip4_addr, ARG_net_ip4_addr(cfg.addr));
-	log_debugf(":: gateway_addr = "PRI_net_ip4_addr, ARG_net_ip4_addr(cfg.gateway_addr));
-	log_debugf(":: subnet_mask  = "PRI_net_ip4_addr, ARG_net_ip4_addr(cfg.subnet_mask));
+	log_debugln("if_up()");
+	log_debugln(":: addr         = ", (net_ip4_addr, cfg.addr));
+	log_debugln(":: gateway_addr = ", (net_ip4_addr, cfg.gateway_addr));
+	log_debugln(":: subnet_mask  = ", (net_ip4_addr, cfg.subnet_mask));
 	_w5500_if_up(chip, cfg);
 }
 
 static void w5500_if_ifdown(struct w5500 *chip) {
-	log_debugf("if_down()");
+	log_debugln("if_down()");
 	_w5500_if_up(chip, (struct net_iface_config){});
 }
 
@@ -444,10 +444,10 @@ static lo_interface net_stream_listener w5500_if_tcp_listen(struct w5500 *chip,
 
 	struct _w5500_socket *sock = w5500_alloc_socket(chip);
 	if (!sock) {
-		log_debugf("tcp_listen() => no sock");
+		log_debugln("tcp_listen() => no sock");
 		return LO_NULL(net_stream_listener);
 	}
-	log_debugf("tcp_listen() => sock[%"PRIu8"]", sock->socknum);
+	log_debugln("tcp_listen() => sock[", sock->socknum, "]");
 
 	if (!local_port)
 		local_port = w5500_alloc_local_port(chip);
@@ -470,11 +470,11 @@ static lo_interface net_stream_conn w5500_if_tcp_dial(struct w5500 *chip,
 
 	struct _w5500_socket *socket = w5500_alloc_socket(chip);
 	if (!socket) {
-		log_debugf("tcp_dial() => no sock");
+		log_debugln("tcp_dial() => no sock");
 		return LO_NULL(net_stream_conn);
 	}
 	uint8_t socknum = socket->socknum;
-	log_debugf("tcp_dial() => sock[%"PRIu8"]", socknum);
+	log_debugln("tcp_dial() => sock[", socknum, "]");
 
 	uint16_t local_port = w5500_alloc_local_port(chip);
 
@@ -502,7 +502,7 @@ static lo_interface net_stream_conn w5500_if_tcp_dial(struct w5500 *chip,
 	cr_mutex_unlock(&chip->mu);
 	for (;;) {
 		uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
-		log_debugf("tcp_dial(): state=%s", w5500_state_str(state));
+		log_debugln("tcp_dial(): state=", w5500_state_str(state));
 		switch (state) {
 		case STATE_TCP_SYNSENT:
 			cr_yield();
@@ -520,11 +520,11 @@ static lo_interface net_packet_conn w5500_if_udp_conn(struct w5500 *chip, uint16
 
 	struct _w5500_socket *socket = w5500_alloc_socket(chip);
 	if (!socket) {
-		log_debugf("udp_conn() => no sock");
+		log_debugln("udp_conn() => no sock");
 		return LO_NULL(net_packet_conn);
 	}
 	uint8_t socknum = socket->socknum;
-	log_debugf("udp_conn() => sock[%"PRIu8"]", socknum);
+	log_debugln("udp_conn() => sock[", socknum, "]");
 
 	if (!local_port)
 		local_port = w5500_alloc_local_port(chip);
@@ -554,7 +554,7 @@ static lo_interface net_stream_conn w5500_tcplist_accept(struct _w5500_socket *s
 
  restart:
 	if (!socket->list_open) {
-		log_debugf("tcp_listener.accept() => already closed");
+		log_debugln("tcp_listener.accept() => already closed");
 		return LO_NULL(net_stream_conn);
 	}
 
@@ -573,7 +573,7 @@ static lo_interface net_stream_conn w5500_tcplist_accept(struct _w5500_socket *s
 	cr_mutex_unlock(&chip->mu);
 	for (;;) {
 		uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
-		log_debugf("tcp_listener.accept() => state=%s", w5500_state_str(state));
+		log_debugln("tcp_listener.accept() => state=", w5500_state_str(state));
 		switch (state) {
 		case STATE_TCP_LISTEN:
 		case STATE_TCP_SYNRECV:
@@ -592,7 +592,7 @@ static lo_interface net_stream_conn w5500_tcplist_accept(struct _w5500_socket *s
 }
 
 static int w5500_tcplist_close(struct _w5500_socket *socket) {
-	log_debugf("tcp_listener.close()");
+	log_debugln("tcp_listener.close()");
 	ASSERT_SELF(stream_listener, TCP);
 
 	socket->list_open = false;
@@ -609,7 +609,7 @@ static ssize_t w5500_tcp_writev(struct _w5500_socket *socket, const struct iovec
 	for (int i = 0; i < iovcnt; i++)
 		count += iov[i].iov_len;
 	assert(count);
-	log_debugf("tcp_conn.write(%zu)", count);
+	log_debugln("tcp_conn.write(", count, ")");
 	ASSERT_SELF(stream_conn, TCP);
 
 	/* What we really want is to pause until we receive an ACK for
@@ -635,14 +635,14 @@ static ssize_t w5500_tcp_writev(struct _w5500_socket *socket, const struct iovec
 	size_t done = 0;
 	while (done < count) {
 		if (!socket->write_open) {
-			log_debugf(" => soft closed");
+			log_debugln(" => soft closed");
 			return -NET_ECLOSED;
 		}
 		cr_mutex_lock(&chip->mu);
 		uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
 		if (state != STATE_TCP_ESTABLISHED && state != STATE_TCP_CLOSE_WAIT) {
 			cr_mutex_unlock(&chip->mu);
-			log_debugf(" => hard closed");
+			log_debugln(" => hard closed");
 			return -NET_ECLOSED;
 		}
 
@@ -667,11 +667,11 @@ static ssize_t w5500_tcp_writev(struct _w5500_socket *socket, const struct iovec
 		cr_mutex_unlock(&chip->mu);
 		switch (cr_chan_recv(&socket->write_ch)) {
 		case SOCKINTR_SEND_OK:
-			log_debugf(" => sent %zu", freesize);
+			log_debugln(" => sent ", freesize);
 			done += freesize;
 			break;
 		case SOCKINTR_SEND_TIMEOUT:
-			log_debugf(" => ACK timeout");
+			log_debugln(" => ACK timeout");
 			return -NET_EACK_TIMEOUT;
 		case SOCKINTR_SEND_OK|SOCKINTR_SEND_TIMEOUT:
 			assert_notreached("send both OK and timed out?");
@@ -679,12 +679,12 @@ static ssize_t w5500_tcp_writev(struct _w5500_socket *socket, const struct iovec
 			assert_notreached("invalid write_ch bits");
 		}
 	}
-	log_debugf(" => send finished");
+	log_debugln(" => send finished");
 	return done;
 }
 
 static void w5500_tcp_set_read_deadline(struct _w5500_socket *socket, uint64_t ns) {
-	log_debugf("tcp_conn.set_read_deadline(%"PRIu64")", ns);
+	log_debugln("tcp_conn.set_read_deadline(", ns, ")");
 	ASSERT_SELF(stream_conn, TCP);
 	socket->read_deadline_ns = ns;
 }
@@ -701,7 +701,7 @@ static ssize_t w5500_tcp_readv(struct _w5500_socket *socket, const struct iovec
 	for (int i = 0; i < iovcnt; i++)
 		count += iov[i].iov_len;
 	assert(count);
-	log_debugf("tcp_conn.read(%zu)", count);
+	log_debugln("tcp_conn.read(", count, ")");
 	ASSERT_SELF(stream_conn, TCP);
 
 	struct alarmclock_trigger trigger = {};
@@ -716,12 +716,12 @@ static ssize_t w5500_tcp_readv(struct _w5500_socket *socket, const struct iovec
 	for (;;) {
 		if (!socket->read_open) {
 			LO_CALL(bootclock, del_trigger, &trigger);
-			log_debugf(" => soft closed");
+			log_debugln(" => soft closed");
 			return -NET_ECLOSED;
 		}
 		if (socket->read_deadline_ns && socket->read_deadline_ns <= LO_CALL(bootclock, get_time_ns)) {
 			LO_CALL(bootclock, del_trigger, &trigger);
-			log_debugf(" => recv timeout");
+			log_debugln(" => recv timeout");
 			return -NET_ERECV_TIMEOUT;
 		}
 		cr_mutex_lock(&chip->mu);
@@ -734,7 +734,7 @@ static ssize_t w5500_tcp_readv(struct _w5500_socket *socket, const struct iovec
 		default:
 			LO_CALL(bootclock, del_trigger, &trigger);
 			cr_mutex_unlock(&chip->mu);
-			log_debugf(" => hard closed");
+			log_debugln(" => hard closed");
 			return -NET_ECLOSED;
 		}
 
@@ -745,7 +745,7 @@ static ssize_t w5500_tcp_readv(struct _w5500_socket *socket, const struct iovec
 		if (state == STATE_TCP_CLOSE_WAIT) {
 			LO_CALL(bootclock, del_trigger, &trigger);
 			cr_mutex_unlock(&chip->mu);
-			log_debugf(" => EOF");
+			log_debugln(" => EOF");
 			return 0;
 		}
 
@@ -753,7 +753,7 @@ static ssize_t w5500_tcp_readv(struct _w5500_socket *socket, const struct iovec
 		cr_sema_wait(&socket->read_sema);
 	}
 	assert(avail);
-	log_debugf(" => received %"PRIu16" bytes", avail);
+	log_debugln(" => received ", avail, " bytes");
 	uint16_t ptr = uint16be_unmarshal(w5500ll_read_sock_reg(chip->spidev, socknum, rx_read_pointer));
 	/* Read the data.  */
 	if ((size_t)avail > count)
@@ -769,7 +769,7 @@ static ssize_t w5500_tcp_readv(struct _w5500_socket *socket, const struct iovec
 }
 
 static int w5500_tcp_close_inner(struct _w5500_socket *socket, bool rd, bool wr) {
-	log_debugf("tcp_conn.close(rd=%s, wr=%s)", rd ? "true" : "false", wr ? "true" : "false");
+	log_debugln("tcp_conn.close(rd=", rd, ", wr=", wr, ")");
 	ASSERT_SELF(stream_conn, TCP);
 
 	if (rd)
@@ -807,14 +807,14 @@ static int w5500_tcp_close_write(struct _w5500_socket *socket) { return w5500_tc
 
 static ssize_t w5500_udp_sendto(struct _w5500_socket *socket, void *buf, size_t count,
                                 struct net_ip4_addr node, uint16_t port) {
-	log_debugf("udp_conn.sendto()");
+	log_debugln("udp_conn.sendto()");
 	ASSERT_SELF(packet_conn, UDP);
 	assert(buf);
 	assert(count);
 
 	uint16_t bufsize = ((uint16_t)w5500ll_read_sock_reg(chip->spidev, socknum, tx_buf_size))*1024;
 	if (count > bufsize) {
-		log_debugf(" => msg too large");
+		log_debugln(" => msg too large");
 		return -NET_EMSGSIZE;
 	}
 
@@ -823,7 +823,7 @@ static ssize_t w5500_udp_sendto(struct _w5500_socket *socket, void *buf, size_t
 		uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
 		if (state != STATE_UDP) {
 			cr_mutex_unlock(&chip->mu);
-			log_debugf(" => closed");
+			log_debugln(" => closed");
 			return -NET_ECLOSED;
 		}
 
@@ -853,10 +853,10 @@ static ssize_t w5500_udp_sendto(struct _w5500_socket *socket, void *buf, size_t
 	cr_mutex_unlock(&chip->mu);
 	switch (cr_chan_recv(&socket->write_ch)) {
 	case SOCKINTR_SEND_OK:
-		log_debugf(" => sent");
+		log_debugln(" => sent");
 		return count;
 	case SOCKINTR_SEND_TIMEOUT:
-		log_debugf(" => ARP timeout");
+		log_debugln(" => ARP timeout");
 		return -NET_EARP_TIMEOUT;
 	case SOCKINTR_SEND_OK|SOCKINTR_SEND_TIMEOUT:
 		assert_notreached("send both OK and timed out?");
@@ -866,7 +866,7 @@ static ssize_t w5500_udp_sendto(struct _w5500_socket *socket, void *buf, size_t
 }
 
 static void w5500_udp_set_recv_deadline(struct _w5500_socket *socket, uint64_t ns) {
-	log_debugf("udp_conn.set_recv_deadline(%"PRIu64")", ns);
+	log_debugln("udp_conn.set_recv_deadline(", ns, ")");
 	ASSERT_SELF(packet_conn, UDP);
 	socket->read_deadline_ns = ns;
 }
@@ -878,7 +878,7 @@ static void w5500_udp_alarm_handler(void *_arg) {
 
 static ssize_t w5500_udp_recvfrom(struct _w5500_socket *socket, void *buf, size_t count,
                                   struct net_ip4_addr *ret_node, uint16_t *ret_port) {
-	log_debugf("udp_conn.recvfrom()");
+	log_debugln("udp_conn.recvfrom()");
 	ASSERT_SELF(packet_conn, UDP);
 	assert(buf);
 	assert(count);
@@ -895,14 +895,14 @@ static ssize_t w5500_udp_recvfrom(struct _w5500_socket *socket, void *buf, size_
 	for (;;) {
 		if (socket->read_deadline_ns && socket->read_deadline_ns <= LO_CALL(bootclock, get_time_ns)) {
 			LO_CALL(bootclock, del_trigger, &trigger);
-			log_debugf(" => recv timeout");
+			log_debugln(" => recv timeout");
 			return -NET_ERECV_TIMEOUT;
 		}
 		cr_mutex_lock(&chip->mu);
 		uint8_t state = w5500ll_read_sock_reg(chip->spidev, socknum, state);
 		if (state != STATE_UDP) {
 			LO_CALL(bootclock, del_trigger, &trigger);
-			log_debugf(" => hard closed");
+			log_debugln(" => hard closed");
 			return -NET_ECLOSED;
 		}
 
@@ -933,7 +933,7 @@ static ssize_t w5500_udp_recvfrom(struct _w5500_socket *socket, void *buf, size_
 	if (ret_port)
 		*ret_port = uint16be_decode(&hdr[4]);
 	uint16_t len = uint16be_decode(&hdr[6]);
-	log_debugf(" => received %"PRIu16" bytes%s", len, len < avail-8 ? " (plus more messages)" : "");
+	log_debugln(" => received ", len, " bytes", len < avail-8 ? " (plus more messages)" : "");
 	/* Now read the actual data.  */
 	if (count > len)
 		count = len;
@@ -951,7 +951,7 @@ static ssize_t w5500_udp_recvfrom(struct _w5500_socket *socket, void *buf, size_
 }
 
 static int w5500_udp_close(struct _w5500_socket *socket) {
-	log_debugf("udp_conn.close()");
+	log_debugln("udp_conn.close()");
 	ASSERT_SELF(packet_conn, UDP);
 
 	w5500_socket_close(socket);