The NetCanReceive handler return whether the device can or
can not receive new packets. Make it obvious by returning
a boolean type.
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
---
hw/net/i82596.h | 2 +-
include/net/net.h | 2 +-
hw/net/allwinner_emac.c | 2 +-
hw/net/cadence_gem.c | 8 ++++----
hw/net/dp8393x.c | 8 +++-----
hw/net/e1000.c | 2 +-
hw/net/e1000e.c | 2 +-
hw/net/ftgmac100.c | 6 +++---
hw/net/i82596.c | 10 +++++-----
hw/net/imx_fec.c | 2 +-
hw/net/opencores_eth.c | 5 ++---
hw/net/rtl8139.c | 8 ++++----
hw/net/smc91c111.c | 2 +-
hw/net/spapr_llan.c | 4 ++--
hw/net/sungem.c | 6 +++---
hw/net/sunhme.c | 4 ++--
hw/net/virtio-net.c | 10 +++++-----
hw/net/xilinx_ethlite.c | 2 +-
net/filter-buffer.c | 2 +-
net/hub.c | 6 +++---
20 files changed, 45 insertions(+), 48 deletions(-)
diff --git a/hw/net/i82596.h b/hw/net/i82596.h
index 1238ac11f8..f0bbe810eb 100644
--- a/hw/net/i82596.h
+++ b/hw/net/i82596.h
@@ -48,7 +48,7 @@ void i82596_ioport_writel(void *opaque, uint32_t addr, uint32_t val);
uint32_t i82596_ioport_readl(void *opaque, uint32_t addr);
uint32_t i82596_bcr_readw(I82596State *s, uint32_t rap);
ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t size_);
-int i82596_can_receive(NetClientState *nc);
+bool i82596_can_receive(NetClientState *nc);
void i82596_set_link_status(NetClientState *nc);
void i82596_common_init(DeviceState *dev, I82596State *s, NetClientInfo *info);
extern const VMStateDescription vmstate_i82596;
diff --git a/include/net/net.h b/include/net/net.h
index e175ba9677..d191ee777e 100644
--- a/include/net/net.h
+++ b/include/net/net.h
@@ -42,7 +42,7 @@ typedef struct NICConf {
/* Net clients */
typedef void (NetPoll)(NetClientState *, bool enable);
-typedef int (NetCanReceive)(NetClientState *);
+typedef bool (NetCanReceive)(NetClientState *);
typedef ssize_t (NetReceive)(NetClientState *, const uint8_t *, size_t);
typedef ssize_t (NetReceiveIOV)(NetClientState *, const struct iovec *, int);
typedef void (NetCleanup) (NetClientState *);
diff --git a/hw/net/allwinner_emac.c b/hw/net/allwinner_emac.c
index e9bbff8710..ddddf35c45 100644
--- a/hw/net/allwinner_emac.c
+++ b/hw/net/allwinner_emac.c
@@ -178,13 +178,13 @@ static uint32_t fifo8_pop_word(Fifo8 *fifo)
return ret;
}
-static int aw_emac_can_receive(NetClientState *nc)
+static bool aw_emac_can_receive(NetClientState *nc)
{
AwEmacState *s = qemu_get_nic_opaque(nc);
/*
* To avoid packet drops, allow reception only when there is space
* for a full frame: 1522 + 8 (rx headers) + 2 (padding).
*/
return (s->ctl & EMAC_CTL_RX_EN) && (fifo8_num_free(&s->rx_fifo) >= 1532);
}
diff --git a/hw/net/cadence_gem.c b/hw/net/cadence_gem.c
index 6340c1eaf8..51ec5a072d 100644
--- a/hw/net/cadence_gem.c
+++ b/hw/net/cadence_gem.c
@@ -505,44 +505,44 @@ static void phy_update_link(CadenceGEMState *s)
}
}
-static int gem_can_receive(NetClientState *nc)
+static bool gem_can_receive(NetClientState *nc)
{
CadenceGEMState *s;
int i;
s = qemu_get_nic_opaque(nc);
/* Do nothing if receive is not enabled. */
if (!(s->regs[GEM_NWCTRL] & GEM_NWCTRL_RXENA)) {
if (s->can_rx_state != 1) {
s->can_rx_state = 1;
DB_PRINT("can't receive - no enable\n");
}
- return 0;
+ return false;
}
for (i = 0; i < s->num_priority_queues; i++) {
if (rx_desc_get_ownership(s->rx_desc[i]) != 1) {
break;
}
};
if (i == s->num_priority_queues) {
if (s->can_rx_state != 2) {
s->can_rx_state = 2;
DB_PRINT("can't receive - all the buffer descriptors are busy\n");
}
- return 0;
+ return false;
}
if (s->can_rx_state != 0) {
s->can_rx_state = 0;
DB_PRINT("can receive\n");
}
- return 1;
+ return true;
}
/*
* gem_update_int_status:
* Raise or lower interrupt based on current status.
*/
diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
index 8a3504d962..900ba5ca65 100644
--- a/hw/net/dp8393x.c
+++ b/hw/net/dp8393x.c
@@ -414,7 +414,7 @@ static void dp8393x_do_stop_timer(dp8393xState *s)
dp8393x_update_wt_regs(s);
}
-static int dp8393x_can_receive(NetClientState *nc);
+static bool dp8393x_can_receive(NetClientState *nc);
static void dp8393x_do_receiver_enable(dp8393xState *s)
{
@@ -718,13 +718,11 @@ static void dp8393x_watchdog(void *opaque)
dp8393x_update_irq(s);
}
-static int dp8393x_can_receive(NetClientState *nc)
+static bool dp8393x_can_receive(NetClientState *nc)
{
dp8393xState *s = qemu_get_nic_opaque(nc);
- if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN))
- return 0;
- return 1;
+ return !!(s->regs[SONIC_CR] & SONIC_CR_RXEN);
}
static int dp8393x_receive_filter(dp8393xState *s, const uint8_t * buf,
diff --git a/hw/net/e1000.c b/hw/net/e1000.c
index 0b833d5a15..6b89df8f0a 100644
--- a/hw/net/e1000.c
+++ b/hw/net/e1000.c
@@ -845,7 +845,7 @@ static bool e1000_has_rxbufs(E1000State *s, size_t total_size)
return total_size <= bufs * s->rxbuf_size;
}
-static int
+static bool
e1000_can_receive(NetClientState *nc)
{
E1000State *s = qemu_get_nic_opaque(nc);
diff --git a/hw/net/e1000e.c b/hw/net/e1000e.c
index a91dbdca3c..f49fa1c7b1 100644
--- a/hw/net/e1000e.c
+++ b/hw/net/e1000e.c
@@ -199,7 +199,7 @@ static const MemoryRegionOps io_ops = {
},
};
-static int
+static bool
e1000e_nc_can_receive(NetClientState *nc)
{
E1000EState *s = qemu_get_nic_opaque(nc);
diff --git a/hw/net/ftgmac100.c b/hw/net/ftgmac100.c
index 2f92b65d4e..041ed21017 100644
--- a/hw/net/ftgmac100.c
+++ b/hw/net/ftgmac100.c
@@ -562,24 +562,24 @@ static void ftgmac100_do_tx(FTGMAC100State *s, uint32_t tx_ring,
ftgmac100_update_irq(s);
}
-static int ftgmac100_can_receive(NetClientState *nc)
+static bool ftgmac100_can_receive(NetClientState *nc)
{
FTGMAC100State *s = FTGMAC100(qemu_get_nic_opaque(nc));
FTGMAC100Desc bd;
if ((s->maccr & (FTGMAC100_MACCR_RXDMA_EN | FTGMAC100_MACCR_RXMAC_EN))
!= (FTGMAC100_MACCR_RXDMA_EN | FTGMAC100_MACCR_RXMAC_EN)) {
- return 0;
+ return false;
}
if (ftgmac100_read_bd(&bd, s->rx_descriptor)) {
- return 0;
+ return false;
}
return !(bd.des0 & FTGMAC100_RXDES0_RXPKT_RDY);
}
/*
* This is purely informative. The HW can poll the RW (and RX) ring
* buffers for available descriptors but we don't need to trigger a
* timer for that in qemu.
*/
diff --git a/hw/net/i82596.c b/hw/net/i82596.c
index fe9f2390a9..e5547fa3c2 100644
--- a/hw/net/i82596.c
+++ b/hw/net/i82596.c
@@ -474,23 +474,23 @@ void i82596_h_reset(void *opaque)
i82596_s_reset(s);
}
-int i82596_can_receive(NetClientState *nc)
+bool i82596_can_receive(NetClientState *nc)
{
I82596State *s = qemu_get_nic_opaque(nc);
if (s->rx_status == RX_SUSPENDED) {
- return 0;
+ return false;
}
if (!s->lnkst) {
- return 0;
+ return false;
}
if (USE_TIMER && !timer_pending(s->flush_queue_timer)) {
- return 1;
+ return true;
}
- return 1;
+ return true;
}
#define MIN_BUF_SIZE 60
diff --git a/hw/net/imx_fec.c b/hw/net/imx_fec.c
index 6a124a154a..5dec813d6d 100644
--- a/hw/net/imx_fec.c
+++ b/hw/net/imx_fec.c
@@ -1047,11 +1047,11 @@ static void imx_eth_write(void *opaque, hwaddr offset, uint64_t value,
imx_eth_update(s);
}
-static int imx_eth_can_receive(NetClientState *nc)
+static bool imx_eth_can_receive(NetClientState *nc)
{
IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
FEC_PRINTF("\n");
return !!s->regs[ENET_RDAR];
}
diff --git a/hw/net/opencores_eth.c b/hw/net/opencores_eth.c
index 6b338c2f29..2ba0dc8c2f 100644
--- a/hw/net/opencores_eth.c
+++ b/hw/net/opencores_eth.c
@@ -349,12 +349,11 @@ static void open_eth_reset(void *opaque)
open_eth_set_link_status(qemu_get_queue(s->nic));
}
-static int open_eth_can_receive(NetClientState *nc)
+static bool open_eth_can_receive(NetClientState *nc)
{
OpenEthState *s = qemu_get_nic_opaque(nc);
- return GET_REGBIT(s, MODER, RXEN) &&
- (s->regs[TX_BD_NUM] < 0x80);
+ return GET_REGBIT(s, MODER, RXEN) && (s->regs[TX_BD_NUM] < 0x80);
}
static ssize_t open_eth_receive(NetClientState *nc,
diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c
index be9a0af629..70aca7ec26 100644
--- a/hw/net/rtl8139.c
+++ b/hw/net/rtl8139.c
@@ -793,26 +793,26 @@ static bool rtl8139_cp_rx_valid(RTL8139State *s)
return !(s->RxRingAddrLO == 0 && s->RxRingAddrHI == 0);
}
-static int rtl8139_can_receive(NetClientState *nc)
+static bool rtl8139_can_receive(NetClientState *nc)
{
RTL8139State *s = qemu_get_nic_opaque(nc);
int avail;
/* Receive (drop) packets if card is disabled. */
if (!s->clock_enabled) {
- return 1;
+ return true;
}
if (!rtl8139_receiver_enabled(s)) {
- return 1;
+ return true;
}
if (rtl8139_cp_receiver_enabled(s) && rtl8139_cp_rx_valid(s)) {
/* ??? Flow control not implemented in c+ mode.
This is a hack to work around slirp deficiencies anyway. */
- return 1;
+ return true;
}
avail = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr,
s->RxBufferSize);
return avail == 0 || avail >= 1514 || (s->IntrMask & RxOverflow);
}
diff --git a/hw/net/smc91c111.c b/hw/net/smc91c111.c
index 02be60c955..b3240b9335 100644
--- a/hw/net/smc91c111.c
+++ b/hw/net/smc91c111.c
@@ -667,9 +667,9 @@ static void smc91c111_writefn(void *opaque, hwaddr addr,
}
}
-static int smc91c111_can_receive_nc(NetClientState *nc)
+static bool smc91c111_can_receive_nc(NetClientState *nc)
{
smc91c111_state *s = qemu_get_nic_opaque(nc);
return smc91c111_can_receive(s);
}
diff --git a/hw/net/spapr_llan.c b/hw/net/spapr_llan.c
index 80f5a1dd37..a2377025a7 100644
--- a/hw/net/spapr_llan.c
+++ b/hw/net/spapr_llan.c
@@ -110,17 +110,17 @@ typedef struct SpaprVioVlan {
RxBufPool *rx_pool[RX_MAX_POOLS]; /* Receive buffer descriptor pools */
} SpaprVioVlan;
-static int spapr_vlan_can_receive(NetClientState *nc)
+static bool spapr_vlan_can_receive(NetClientState *nc)
{
SpaprVioVlan *dev = qemu_get_nic_opaque(nc);
- return (dev->isopen && dev->rx_bufs > 0);
+ return dev->isopen && dev->rx_bufs > 0;
}
/**
* The last 8 bytes of the receive buffer list page (that has been
* supplied by the guest with the H_REGISTER_LOGICAL_LAN call) contain
* a counter for frames that have been dropped because there was no
* suitable receive buffer available. This function is used to increase
* this counter by one.
*/
diff --git a/hw/net/sungem.c b/hw/net/sungem.c
index 89da51f7f6..b01197d952 100644
--- a/hw/net/sungem.c
+++ b/hw/net/sungem.c
@@ -433,31 +433,31 @@ static bool sungem_rx_full(SunGEMState *s, uint32_t kick, uint32_t done)
return kick == ((done + 1) & s->rx_mask);
}
-static int sungem_can_receive(NetClientState *nc)
+static bool sungem_can_receive(NetClientState *nc)
{
SunGEMState *s = qemu_get_nic_opaque(nc);
uint32_t kick, done, rxdma_cfg, rxmac_cfg;
bool full;
rxmac_cfg = s->macregs[MAC_RXCFG >> 2];
rxdma_cfg = s->rxdmaregs[RXDMA_CFG >> 2];
/* If MAC disabled, can't receive */
if ((rxmac_cfg & MAC_RXCFG_ENAB) == 0) {
trace_sungem_rx_mac_disabled();
- return 0;
+ return false;
}
if ((rxdma_cfg & RXDMA_CFG_ENABLE) == 0) {
trace_sungem_rx_txdma_disabled();
- return 0;
+ return false;
}
/* Check RX availability */
kick = s->rxdmaregs[RXDMA_KICK >> 2];
done = s->rxdmaregs[RXDMA_DONE >> 2];
full = sungem_rx_full(s, kick, done);
trace_sungem_rx_check(!full, kick, done);
return !full;
}
diff --git a/hw/net/sunhme.c b/hw/net/sunhme.c
index 8863601f6c..9c38583180 100644
--- a/hw/net/sunhme.c
+++ b/hw/net/sunhme.c
@@ -657,11 +657,11 @@ static void sunhme_transmit(SunHMEState *s)
sunhme_update_irq(s);
}
-static int sunhme_can_receive(NetClientState *nc)
+static bool sunhme_can_receive(NetClientState *nc)
{
SunHMEState *s = qemu_get_nic_opaque(nc);
- return s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_ENABLE;
+ return !!(s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_ENABLE);
}
static void sunhme_link_status_changed(NetClientState *nc)
diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
index 3627bb1717..a46e3b37a7 100644
--- a/hw/net/virtio-net.c
+++ b/hw/net/virtio-net.c
@@ -1234,26 +1234,26 @@ static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
}
-static int virtio_net_can_receive(NetClientState *nc)
+static bool virtio_net_can_receive(NetClientState *nc)
{
VirtIONet *n = qemu_get_nic_opaque(nc);
VirtIODevice *vdev = VIRTIO_DEVICE(n);
VirtIONetQueue *q = virtio_net_get_subqueue(nc);
if (!vdev->vm_running) {
- return 0;
+ return false;
}
if (nc->queue_index >= n->curr_queues) {
- return 0;
+ return false;
}
if (!virtio_queue_ready(q->rx_vq) ||
!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
- return 0;
+ return false;
}
- return 1;
+ return true;
}
static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
diff --git a/hw/net/xilinx_ethlite.c b/hw/net/xilinx_ethlite.c
index cf07e698b3..71d16fef3d 100644
--- a/hw/net/xilinx_ethlite.c
+++ b/hw/net/xilinx_ethlite.c
@@ -175,10 +175,10 @@ static const MemoryRegionOps eth_ops = {
}
};
-static int eth_can_rx(NetClientState *nc)
+static bool eth_can_rx(NetClientState *nc)
{
struct xlx_ethlite *s = qemu_get_nic_opaque(nc);
unsigned int rxbase = s->rxbuf * (0x800 / 4);
return !(s->regs[rxbase + R_RX_CTRL0] & CTRL_S);
}
diff --git a/net/filter-buffer.c b/net/filter-buffer.c
index 88da78f821..12e0254287 100644
--- a/net/filter-buffer.c
+++ b/net/filter-buffer.c
@@ -59,28 +59,28 @@ static void filter_buffer_release_timer(void *opaque)
/* filter APIs */
static ssize_t filter_buffer_receive_iov(NetFilterState *nf,
NetClientState *sender,
unsigned flags,
const struct iovec *iov,
int iovcnt,
NetPacketSent *sent_cb)
{
FilterBufferState *s = FILTER_BUFFER(nf);
/*
* We return size when buffer a packet, the sender will take it as
* a already sent packet, so sent_cb should not be called later.
*
* FIXME: Even if the guest can't receive packets for some reasons,
* the filter can still accept packets until its internal queue is full.
* For example:
* For some reason, receiver could not receive more packets
- * (.can_receive() returns zero). Without a filter, at most one packet
+ * (.can_receive() returns false). Without a filter, at most one packet
* will be queued in incoming queue and sender's poll will be disabled
* unit its sent_cb() was called. With a filter, it will keep receiving
* the packets without caring about the receiver. This is suboptimal.
* May need more thoughts (e.g keeping sent_cb).
*/
qemu_net_queue_append_iov(s->incoming_queue, sender, flags,
iov, iovcnt, NULL);
return iov_size(iov, iovcnt);
}
diff --git a/net/hub.c b/net/hub.c
index 5795a678ed..e7de173171 100644
--- a/net/hub.c
+++ b/net/hub.c
@@ -90,23 +90,23 @@ static NetHub *net_hub_new(int id)
return hub;
}
-static int net_hub_port_can_receive(NetClientState *nc)
+static bool net_hub_port_can_receive(NetClientState *nc)
{
NetHubPort *port;
NetHubPort *src_port = DO_UPCAST(NetHubPort, nc, nc);
NetHub *hub = src_port->hub;
QLIST_FOREACH(port, &hub->ports, next) {
if (port == src_port) {
continue;
}
if (qemu_can_send_packet(&port->nc)) {
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
static ssize_t net_hub_port_receive(NetClientState *nc,
--
2.21.1
On Thu, Mar 05, 2020 at 06:56:49PM +0100, Philippe Mathieu-Daudé wrote:
> The NetCanReceive handler return whether the device can or
> can not receive new packets. Make it obvious by returning
> a boolean type.
>
> Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
ppc parts
Acked-by: David Gibson <david@gibson.dropbear.id.au>
> ---
> hw/net/i82596.h | 2 +-
> include/net/net.h | 2 +-
> hw/net/allwinner_emac.c | 2 +-
> hw/net/cadence_gem.c | 8 ++++----
> hw/net/dp8393x.c | 8 +++-----
> hw/net/e1000.c | 2 +-
> hw/net/e1000e.c | 2 +-
> hw/net/ftgmac100.c | 6 +++---
> hw/net/i82596.c | 10 +++++-----
> hw/net/imx_fec.c | 2 +-
> hw/net/opencores_eth.c | 5 ++---
> hw/net/rtl8139.c | 8 ++++----
> hw/net/smc91c111.c | 2 +-
> hw/net/spapr_llan.c | 4 ++--
> hw/net/sungem.c | 6 +++---
> hw/net/sunhme.c | 4 ++--
> hw/net/virtio-net.c | 10 +++++-----
> hw/net/xilinx_ethlite.c | 2 +-
> net/filter-buffer.c | 2 +-
> net/hub.c | 6 +++---
> 20 files changed, 45 insertions(+), 48 deletions(-)
>
> diff --git a/hw/net/i82596.h b/hw/net/i82596.h
> index 1238ac11f8..f0bbe810eb 100644
> --- a/hw/net/i82596.h
> +++ b/hw/net/i82596.h
> @@ -48,7 +48,7 @@ void i82596_ioport_writel(void *opaque, uint32_t addr, uint32_t val);
> uint32_t i82596_ioport_readl(void *opaque, uint32_t addr);
> uint32_t i82596_bcr_readw(I82596State *s, uint32_t rap);
> ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t size_);
> -int i82596_can_receive(NetClientState *nc);
> +bool i82596_can_receive(NetClientState *nc);
> void i82596_set_link_status(NetClientState *nc);
> void i82596_common_init(DeviceState *dev, I82596State *s, NetClientInfo *info);
> extern const VMStateDescription vmstate_i82596;
> diff --git a/include/net/net.h b/include/net/net.h
> index e175ba9677..d191ee777e 100644
> --- a/include/net/net.h
> +++ b/include/net/net.h
> @@ -42,7 +42,7 @@ typedef struct NICConf {
> /* Net clients */
>
> typedef void (NetPoll)(NetClientState *, bool enable);
> -typedef int (NetCanReceive)(NetClientState *);
> +typedef bool (NetCanReceive)(NetClientState *);
> typedef ssize_t (NetReceive)(NetClientState *, const uint8_t *, size_t);
> typedef ssize_t (NetReceiveIOV)(NetClientState *, const struct iovec *, int);
> typedef void (NetCleanup) (NetClientState *);
> diff --git a/hw/net/allwinner_emac.c b/hw/net/allwinner_emac.c
> index e9bbff8710..ddddf35c45 100644
> --- a/hw/net/allwinner_emac.c
> +++ b/hw/net/allwinner_emac.c
> @@ -178,13 +178,13 @@ static uint32_t fifo8_pop_word(Fifo8 *fifo)
> return ret;
> }
>
> -static int aw_emac_can_receive(NetClientState *nc)
> +static bool aw_emac_can_receive(NetClientState *nc)
> {
> AwEmacState *s = qemu_get_nic_opaque(nc);
>
> /*
> * To avoid packet drops, allow reception only when there is space
> * for a full frame: 1522 + 8 (rx headers) + 2 (padding).
> */
> return (s->ctl & EMAC_CTL_RX_EN) && (fifo8_num_free(&s->rx_fifo) >= 1532);
> }
> diff --git a/hw/net/cadence_gem.c b/hw/net/cadence_gem.c
> index 6340c1eaf8..51ec5a072d 100644
> --- a/hw/net/cadence_gem.c
> +++ b/hw/net/cadence_gem.c
> @@ -505,44 +505,44 @@ static void phy_update_link(CadenceGEMState *s)
> }
> }
>
> -static int gem_can_receive(NetClientState *nc)
> +static bool gem_can_receive(NetClientState *nc)
> {
> CadenceGEMState *s;
> int i;
>
> s = qemu_get_nic_opaque(nc);
>
> /* Do nothing if receive is not enabled. */
> if (!(s->regs[GEM_NWCTRL] & GEM_NWCTRL_RXENA)) {
> if (s->can_rx_state != 1) {
> s->can_rx_state = 1;
> DB_PRINT("can't receive - no enable\n");
> }
> - return 0;
> + return false;
> }
>
> for (i = 0; i < s->num_priority_queues; i++) {
> if (rx_desc_get_ownership(s->rx_desc[i]) != 1) {
> break;
> }
> };
>
> if (i == s->num_priority_queues) {
> if (s->can_rx_state != 2) {
> s->can_rx_state = 2;
> DB_PRINT("can't receive - all the buffer descriptors are busy\n");
> }
> - return 0;
> + return false;
> }
>
> if (s->can_rx_state != 0) {
> s->can_rx_state = 0;
> DB_PRINT("can receive\n");
> }
> - return 1;
> + return true;
> }
>
> /*
> * gem_update_int_status:
> * Raise or lower interrupt based on current status.
> */
> diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
> index 8a3504d962..900ba5ca65 100644
> --- a/hw/net/dp8393x.c
> +++ b/hw/net/dp8393x.c
> @@ -414,7 +414,7 @@ static void dp8393x_do_stop_timer(dp8393xState *s)
> dp8393x_update_wt_regs(s);
> }
>
> -static int dp8393x_can_receive(NetClientState *nc);
> +static bool dp8393x_can_receive(NetClientState *nc);
>
> static void dp8393x_do_receiver_enable(dp8393xState *s)
> {
> @@ -718,13 +718,11 @@ static void dp8393x_watchdog(void *opaque)
> dp8393x_update_irq(s);
> }
>
> -static int dp8393x_can_receive(NetClientState *nc)
> +static bool dp8393x_can_receive(NetClientState *nc)
> {
> dp8393xState *s = qemu_get_nic_opaque(nc);
>
> - if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN))
> - return 0;
> - return 1;
> + return !!(s->regs[SONIC_CR] & SONIC_CR_RXEN);
> }
>
> static int dp8393x_receive_filter(dp8393xState *s, const uint8_t * buf,
> diff --git a/hw/net/e1000.c b/hw/net/e1000.c
> index 0b833d5a15..6b89df8f0a 100644
> --- a/hw/net/e1000.c
> +++ b/hw/net/e1000.c
> @@ -845,7 +845,7 @@ static bool e1000_has_rxbufs(E1000State *s, size_t total_size)
> return total_size <= bufs * s->rxbuf_size;
> }
>
> -static int
> +static bool
> e1000_can_receive(NetClientState *nc)
> {
> E1000State *s = qemu_get_nic_opaque(nc);
> diff --git a/hw/net/e1000e.c b/hw/net/e1000e.c
> index a91dbdca3c..f49fa1c7b1 100644
> --- a/hw/net/e1000e.c
> +++ b/hw/net/e1000e.c
> @@ -199,7 +199,7 @@ static const MemoryRegionOps io_ops = {
> },
> };
>
> -static int
> +static bool
> e1000e_nc_can_receive(NetClientState *nc)
> {
> E1000EState *s = qemu_get_nic_opaque(nc);
> diff --git a/hw/net/ftgmac100.c b/hw/net/ftgmac100.c
> index 2f92b65d4e..041ed21017 100644
> --- a/hw/net/ftgmac100.c
> +++ b/hw/net/ftgmac100.c
> @@ -562,24 +562,24 @@ static void ftgmac100_do_tx(FTGMAC100State *s, uint32_t tx_ring,
> ftgmac100_update_irq(s);
> }
>
> -static int ftgmac100_can_receive(NetClientState *nc)
> +static bool ftgmac100_can_receive(NetClientState *nc)
> {
> FTGMAC100State *s = FTGMAC100(qemu_get_nic_opaque(nc));
> FTGMAC100Desc bd;
>
> if ((s->maccr & (FTGMAC100_MACCR_RXDMA_EN | FTGMAC100_MACCR_RXMAC_EN))
> != (FTGMAC100_MACCR_RXDMA_EN | FTGMAC100_MACCR_RXMAC_EN)) {
> - return 0;
> + return false;
> }
>
> if (ftgmac100_read_bd(&bd, s->rx_descriptor)) {
> - return 0;
> + return false;
> }
> return !(bd.des0 & FTGMAC100_RXDES0_RXPKT_RDY);
> }
>
> /*
> * This is purely informative. The HW can poll the RW (and RX) ring
> * buffers for available descriptors but we don't need to trigger a
> * timer for that in qemu.
> */
> diff --git a/hw/net/i82596.c b/hw/net/i82596.c
> index fe9f2390a9..e5547fa3c2 100644
> --- a/hw/net/i82596.c
> +++ b/hw/net/i82596.c
> @@ -474,23 +474,23 @@ void i82596_h_reset(void *opaque)
> i82596_s_reset(s);
> }
>
> -int i82596_can_receive(NetClientState *nc)
> +bool i82596_can_receive(NetClientState *nc)
> {
> I82596State *s = qemu_get_nic_opaque(nc);
>
> if (s->rx_status == RX_SUSPENDED) {
> - return 0;
> + return false;
> }
>
> if (!s->lnkst) {
> - return 0;
> + return false;
> }
>
> if (USE_TIMER && !timer_pending(s->flush_queue_timer)) {
> - return 1;
> + return true;
> }
>
> - return 1;
> + return true;
> }
>
> #define MIN_BUF_SIZE 60
> diff --git a/hw/net/imx_fec.c b/hw/net/imx_fec.c
> index 6a124a154a..5dec813d6d 100644
> --- a/hw/net/imx_fec.c
> +++ b/hw/net/imx_fec.c
> @@ -1047,11 +1047,11 @@ static void imx_eth_write(void *opaque, hwaddr offset, uint64_t value,
> imx_eth_update(s);
> }
>
> -static int imx_eth_can_receive(NetClientState *nc)
> +static bool imx_eth_can_receive(NetClientState *nc)
> {
> IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
>
> FEC_PRINTF("\n");
>
> return !!s->regs[ENET_RDAR];
> }
> diff --git a/hw/net/opencores_eth.c b/hw/net/opencores_eth.c
> index 6b338c2f29..2ba0dc8c2f 100644
> --- a/hw/net/opencores_eth.c
> +++ b/hw/net/opencores_eth.c
> @@ -349,12 +349,11 @@ static void open_eth_reset(void *opaque)
> open_eth_set_link_status(qemu_get_queue(s->nic));
> }
>
> -static int open_eth_can_receive(NetClientState *nc)
> +static bool open_eth_can_receive(NetClientState *nc)
> {
> OpenEthState *s = qemu_get_nic_opaque(nc);
>
> - return GET_REGBIT(s, MODER, RXEN) &&
> - (s->regs[TX_BD_NUM] < 0x80);
> + return GET_REGBIT(s, MODER, RXEN) && (s->regs[TX_BD_NUM] < 0x80);
> }
>
> static ssize_t open_eth_receive(NetClientState *nc,
> diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c
> index be9a0af629..70aca7ec26 100644
> --- a/hw/net/rtl8139.c
> +++ b/hw/net/rtl8139.c
> @@ -793,26 +793,26 @@ static bool rtl8139_cp_rx_valid(RTL8139State *s)
> return !(s->RxRingAddrLO == 0 && s->RxRingAddrHI == 0);
> }
>
> -static int rtl8139_can_receive(NetClientState *nc)
> +static bool rtl8139_can_receive(NetClientState *nc)
> {
> RTL8139State *s = qemu_get_nic_opaque(nc);
> int avail;
>
> /* Receive (drop) packets if card is disabled. */
> if (!s->clock_enabled) {
> - return 1;
> + return true;
> }
> if (!rtl8139_receiver_enabled(s)) {
> - return 1;
> + return true;
> }
>
> if (rtl8139_cp_receiver_enabled(s) && rtl8139_cp_rx_valid(s)) {
> /* ??? Flow control not implemented in c+ mode.
> This is a hack to work around slirp deficiencies anyway. */
> - return 1;
> + return true;
> }
>
> avail = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr,
> s->RxBufferSize);
> return avail == 0 || avail >= 1514 || (s->IntrMask & RxOverflow);
> }
> diff --git a/hw/net/smc91c111.c b/hw/net/smc91c111.c
> index 02be60c955..b3240b9335 100644
> --- a/hw/net/smc91c111.c
> +++ b/hw/net/smc91c111.c
> @@ -667,9 +667,9 @@ static void smc91c111_writefn(void *opaque, hwaddr addr,
> }
> }
>
> -static int smc91c111_can_receive_nc(NetClientState *nc)
> +static bool smc91c111_can_receive_nc(NetClientState *nc)
> {
> smc91c111_state *s = qemu_get_nic_opaque(nc);
>
> return smc91c111_can_receive(s);
> }
> diff --git a/hw/net/spapr_llan.c b/hw/net/spapr_llan.c
> index 80f5a1dd37..a2377025a7 100644
> --- a/hw/net/spapr_llan.c
> +++ b/hw/net/spapr_llan.c
> @@ -110,17 +110,17 @@ typedef struct SpaprVioVlan {
> RxBufPool *rx_pool[RX_MAX_POOLS]; /* Receive buffer descriptor pools */
> } SpaprVioVlan;
>
> -static int spapr_vlan_can_receive(NetClientState *nc)
> +static bool spapr_vlan_can_receive(NetClientState *nc)
> {
> SpaprVioVlan *dev = qemu_get_nic_opaque(nc);
>
> - return (dev->isopen && dev->rx_bufs > 0);
> + return dev->isopen && dev->rx_bufs > 0;
> }
>
> /**
> * The last 8 bytes of the receive buffer list page (that has been
> * supplied by the guest with the H_REGISTER_LOGICAL_LAN call) contain
> * a counter for frames that have been dropped because there was no
> * suitable receive buffer available. This function is used to increase
> * this counter by one.
> */
> diff --git a/hw/net/sungem.c b/hw/net/sungem.c
> index 89da51f7f6..b01197d952 100644
> --- a/hw/net/sungem.c
> +++ b/hw/net/sungem.c
> @@ -433,31 +433,31 @@ static bool sungem_rx_full(SunGEMState *s, uint32_t kick, uint32_t done)
> return kick == ((done + 1) & s->rx_mask);
> }
>
> -static int sungem_can_receive(NetClientState *nc)
> +static bool sungem_can_receive(NetClientState *nc)
> {
> SunGEMState *s = qemu_get_nic_opaque(nc);
> uint32_t kick, done, rxdma_cfg, rxmac_cfg;
> bool full;
>
> rxmac_cfg = s->macregs[MAC_RXCFG >> 2];
> rxdma_cfg = s->rxdmaregs[RXDMA_CFG >> 2];
>
> /* If MAC disabled, can't receive */
> if ((rxmac_cfg & MAC_RXCFG_ENAB) == 0) {
> trace_sungem_rx_mac_disabled();
> - return 0;
> + return false;
> }
> if ((rxdma_cfg & RXDMA_CFG_ENABLE) == 0) {
> trace_sungem_rx_txdma_disabled();
> - return 0;
> + return false;
> }
>
> /* Check RX availability */
> kick = s->rxdmaregs[RXDMA_KICK >> 2];
> done = s->rxdmaregs[RXDMA_DONE >> 2];
> full = sungem_rx_full(s, kick, done);
>
> trace_sungem_rx_check(!full, kick, done);
>
> return !full;
> }
> diff --git a/hw/net/sunhme.c b/hw/net/sunhme.c
> index 8863601f6c..9c38583180 100644
> --- a/hw/net/sunhme.c
> +++ b/hw/net/sunhme.c
> @@ -657,11 +657,11 @@ static void sunhme_transmit(SunHMEState *s)
> sunhme_update_irq(s);
> }
>
> -static int sunhme_can_receive(NetClientState *nc)
> +static bool sunhme_can_receive(NetClientState *nc)
> {
> SunHMEState *s = qemu_get_nic_opaque(nc);
>
> - return s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_ENABLE;
> + return !!(s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_ENABLE);
> }
>
> static void sunhme_link_status_changed(NetClientState *nc)
> diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
> index 3627bb1717..a46e3b37a7 100644
> --- a/hw/net/virtio-net.c
> +++ b/hw/net/virtio-net.c
> @@ -1234,26 +1234,26 @@ static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
> qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
> }
>
> -static int virtio_net_can_receive(NetClientState *nc)
> +static bool virtio_net_can_receive(NetClientState *nc)
> {
> VirtIONet *n = qemu_get_nic_opaque(nc);
> VirtIODevice *vdev = VIRTIO_DEVICE(n);
> VirtIONetQueue *q = virtio_net_get_subqueue(nc);
>
> if (!vdev->vm_running) {
> - return 0;
> + return false;
> }
>
> if (nc->queue_index >= n->curr_queues) {
> - return 0;
> + return false;
> }
>
> if (!virtio_queue_ready(q->rx_vq) ||
> !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
> - return 0;
> + return false;
> }
>
> - return 1;
> + return true;
> }
>
> static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
> diff --git a/hw/net/xilinx_ethlite.c b/hw/net/xilinx_ethlite.c
> index cf07e698b3..71d16fef3d 100644
> --- a/hw/net/xilinx_ethlite.c
> +++ b/hw/net/xilinx_ethlite.c
> @@ -175,10 +175,10 @@ static const MemoryRegionOps eth_ops = {
> }
> };
>
> -static int eth_can_rx(NetClientState *nc)
> +static bool eth_can_rx(NetClientState *nc)
> {
> struct xlx_ethlite *s = qemu_get_nic_opaque(nc);
> unsigned int rxbase = s->rxbuf * (0x800 / 4);
>
> return !(s->regs[rxbase + R_RX_CTRL0] & CTRL_S);
> }
> diff --git a/net/filter-buffer.c b/net/filter-buffer.c
> index 88da78f821..12e0254287 100644
> --- a/net/filter-buffer.c
> +++ b/net/filter-buffer.c
> @@ -59,28 +59,28 @@ static void filter_buffer_release_timer(void *opaque)
> /* filter APIs */
> static ssize_t filter_buffer_receive_iov(NetFilterState *nf,
> NetClientState *sender,
> unsigned flags,
> const struct iovec *iov,
> int iovcnt,
> NetPacketSent *sent_cb)
> {
> FilterBufferState *s = FILTER_BUFFER(nf);
>
> /*
> * We return size when buffer a packet, the sender will take it as
> * a already sent packet, so sent_cb should not be called later.
> *
> * FIXME: Even if the guest can't receive packets for some reasons,
> * the filter can still accept packets until its internal queue is full.
> * For example:
> * For some reason, receiver could not receive more packets
> - * (.can_receive() returns zero). Without a filter, at most one packet
> + * (.can_receive() returns false). Without a filter, at most one packet
> * will be queued in incoming queue and sender's poll will be disabled
> * unit its sent_cb() was called. With a filter, it will keep receiving
> * the packets without caring about the receiver. This is suboptimal.
> * May need more thoughts (e.g keeping sent_cb).
> */
> qemu_net_queue_append_iov(s->incoming_queue, sender, flags,
> iov, iovcnt, NULL);
> return iov_size(iov, iovcnt);
> }
> diff --git a/net/hub.c b/net/hub.c
> index 5795a678ed..e7de173171 100644
> --- a/net/hub.c
> +++ b/net/hub.c
> @@ -90,23 +90,23 @@ static NetHub *net_hub_new(int id)
> return hub;
> }
>
> -static int net_hub_port_can_receive(NetClientState *nc)
> +static bool net_hub_port_can_receive(NetClientState *nc)
> {
> NetHubPort *port;
> NetHubPort *src_port = DO_UPCAST(NetHubPort, nc, nc);
> NetHub *hub = src_port->hub;
>
> QLIST_FOREACH(port, &hub->ports, next) {
> if (port == src_port) {
> continue;
> }
>
> if (qemu_can_send_packet(&port->nc)) {
> - return 1;
> + return true;
> }
> }
>
> - return 0;
> + return false;
> }
>
> static ssize_t net_hub_port_receive(NetClientState *nc,
--
David Gibson | I'll have my music baroque, and my code
david AT gibson.dropbear.id.au | minimalist, thank you. NOT _the_ _other_
| _way_ _around_!
http://www.ozlabs.org/~dgibson
On Thu, Mar 5, 2020 at 9:57 AM Philippe Mathieu-Daudé <philmd@redhat.com> wrote:
>
> The NetCanReceive handler return whether the device can or
> can not receive new packets. Make it obvious by returning
> a boolean type.
>
> Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Alistair
> ---
> hw/net/i82596.h | 2 +-
> include/net/net.h | 2 +-
> hw/net/allwinner_emac.c | 2 +-
> hw/net/cadence_gem.c | 8 ++++----
> hw/net/dp8393x.c | 8 +++-----
> hw/net/e1000.c | 2 +-
> hw/net/e1000e.c | 2 +-
> hw/net/ftgmac100.c | 6 +++---
> hw/net/i82596.c | 10 +++++-----
> hw/net/imx_fec.c | 2 +-
> hw/net/opencores_eth.c | 5 ++---
> hw/net/rtl8139.c | 8 ++++----
> hw/net/smc91c111.c | 2 +-
> hw/net/spapr_llan.c | 4 ++--
> hw/net/sungem.c | 6 +++---
> hw/net/sunhme.c | 4 ++--
> hw/net/virtio-net.c | 10 +++++-----
> hw/net/xilinx_ethlite.c | 2 +-
> net/filter-buffer.c | 2 +-
> net/hub.c | 6 +++---
> 20 files changed, 45 insertions(+), 48 deletions(-)
>
> diff --git a/hw/net/i82596.h b/hw/net/i82596.h
> index 1238ac11f8..f0bbe810eb 100644
> --- a/hw/net/i82596.h
> +++ b/hw/net/i82596.h
> @@ -48,7 +48,7 @@ void i82596_ioport_writel(void *opaque, uint32_t addr, uint32_t val);
> uint32_t i82596_ioport_readl(void *opaque, uint32_t addr);
> uint32_t i82596_bcr_readw(I82596State *s, uint32_t rap);
> ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t size_);
> -int i82596_can_receive(NetClientState *nc);
> +bool i82596_can_receive(NetClientState *nc);
> void i82596_set_link_status(NetClientState *nc);
> void i82596_common_init(DeviceState *dev, I82596State *s, NetClientInfo *info);
> extern const VMStateDescription vmstate_i82596;
> diff --git a/include/net/net.h b/include/net/net.h
> index e175ba9677..d191ee777e 100644
> --- a/include/net/net.h
> +++ b/include/net/net.h
> @@ -42,7 +42,7 @@ typedef struct NICConf {
> /* Net clients */
>
> typedef void (NetPoll)(NetClientState *, bool enable);
> -typedef int (NetCanReceive)(NetClientState *);
> +typedef bool (NetCanReceive)(NetClientState *);
> typedef ssize_t (NetReceive)(NetClientState *, const uint8_t *, size_t);
> typedef ssize_t (NetReceiveIOV)(NetClientState *, const struct iovec *, int);
> typedef void (NetCleanup) (NetClientState *);
> diff --git a/hw/net/allwinner_emac.c b/hw/net/allwinner_emac.c
> index e9bbff8710..ddddf35c45 100644
> --- a/hw/net/allwinner_emac.c
> +++ b/hw/net/allwinner_emac.c
> @@ -178,13 +178,13 @@ static uint32_t fifo8_pop_word(Fifo8 *fifo)
> return ret;
> }
>
> -static int aw_emac_can_receive(NetClientState *nc)
> +static bool aw_emac_can_receive(NetClientState *nc)
> {
> AwEmacState *s = qemu_get_nic_opaque(nc);
>
> /*
> * To avoid packet drops, allow reception only when there is space
> * for a full frame: 1522 + 8 (rx headers) + 2 (padding).
> */
> return (s->ctl & EMAC_CTL_RX_EN) && (fifo8_num_free(&s->rx_fifo) >= 1532);
> }
> diff --git a/hw/net/cadence_gem.c b/hw/net/cadence_gem.c
> index 6340c1eaf8..51ec5a072d 100644
> --- a/hw/net/cadence_gem.c
> +++ b/hw/net/cadence_gem.c
> @@ -505,44 +505,44 @@ static void phy_update_link(CadenceGEMState *s)
> }
> }
>
> -static int gem_can_receive(NetClientState *nc)
> +static bool gem_can_receive(NetClientState *nc)
> {
> CadenceGEMState *s;
> int i;
>
> s = qemu_get_nic_opaque(nc);
>
> /* Do nothing if receive is not enabled. */
> if (!(s->regs[GEM_NWCTRL] & GEM_NWCTRL_RXENA)) {
> if (s->can_rx_state != 1) {
> s->can_rx_state = 1;
> DB_PRINT("can't receive - no enable\n");
> }
> - return 0;
> + return false;
> }
>
> for (i = 0; i < s->num_priority_queues; i++) {
> if (rx_desc_get_ownership(s->rx_desc[i]) != 1) {
> break;
> }
> };
>
> if (i == s->num_priority_queues) {
> if (s->can_rx_state != 2) {
> s->can_rx_state = 2;
> DB_PRINT("can't receive - all the buffer descriptors are busy\n");
> }
> - return 0;
> + return false;
> }
>
> if (s->can_rx_state != 0) {
> s->can_rx_state = 0;
> DB_PRINT("can receive\n");
> }
> - return 1;
> + return true;
> }
>
> /*
> * gem_update_int_status:
> * Raise or lower interrupt based on current status.
> */
> diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
> index 8a3504d962..900ba5ca65 100644
> --- a/hw/net/dp8393x.c
> +++ b/hw/net/dp8393x.c
> @@ -414,7 +414,7 @@ static void dp8393x_do_stop_timer(dp8393xState *s)
> dp8393x_update_wt_regs(s);
> }
>
> -static int dp8393x_can_receive(NetClientState *nc);
> +static bool dp8393x_can_receive(NetClientState *nc);
>
> static void dp8393x_do_receiver_enable(dp8393xState *s)
> {
> @@ -718,13 +718,11 @@ static void dp8393x_watchdog(void *opaque)
> dp8393x_update_irq(s);
> }
>
> -static int dp8393x_can_receive(NetClientState *nc)
> +static bool dp8393x_can_receive(NetClientState *nc)
> {
> dp8393xState *s = qemu_get_nic_opaque(nc);
>
> - if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN))
> - return 0;
> - return 1;
> + return !!(s->regs[SONIC_CR] & SONIC_CR_RXEN);
> }
>
> static int dp8393x_receive_filter(dp8393xState *s, const uint8_t * buf,
> diff --git a/hw/net/e1000.c b/hw/net/e1000.c
> index 0b833d5a15..6b89df8f0a 100644
> --- a/hw/net/e1000.c
> +++ b/hw/net/e1000.c
> @@ -845,7 +845,7 @@ static bool e1000_has_rxbufs(E1000State *s, size_t total_size)
> return total_size <= bufs * s->rxbuf_size;
> }
>
> -static int
> +static bool
> e1000_can_receive(NetClientState *nc)
> {
> E1000State *s = qemu_get_nic_opaque(nc);
> diff --git a/hw/net/e1000e.c b/hw/net/e1000e.c
> index a91dbdca3c..f49fa1c7b1 100644
> --- a/hw/net/e1000e.c
> +++ b/hw/net/e1000e.c
> @@ -199,7 +199,7 @@ static const MemoryRegionOps io_ops = {
> },
> };
>
> -static int
> +static bool
> e1000e_nc_can_receive(NetClientState *nc)
> {
> E1000EState *s = qemu_get_nic_opaque(nc);
> diff --git a/hw/net/ftgmac100.c b/hw/net/ftgmac100.c
> index 2f92b65d4e..041ed21017 100644
> --- a/hw/net/ftgmac100.c
> +++ b/hw/net/ftgmac100.c
> @@ -562,24 +562,24 @@ static void ftgmac100_do_tx(FTGMAC100State *s, uint32_t tx_ring,
> ftgmac100_update_irq(s);
> }
>
> -static int ftgmac100_can_receive(NetClientState *nc)
> +static bool ftgmac100_can_receive(NetClientState *nc)
> {
> FTGMAC100State *s = FTGMAC100(qemu_get_nic_opaque(nc));
> FTGMAC100Desc bd;
>
> if ((s->maccr & (FTGMAC100_MACCR_RXDMA_EN | FTGMAC100_MACCR_RXMAC_EN))
> != (FTGMAC100_MACCR_RXDMA_EN | FTGMAC100_MACCR_RXMAC_EN)) {
> - return 0;
> + return false;
> }
>
> if (ftgmac100_read_bd(&bd, s->rx_descriptor)) {
> - return 0;
> + return false;
> }
> return !(bd.des0 & FTGMAC100_RXDES0_RXPKT_RDY);
> }
>
> /*
> * This is purely informative. The HW can poll the RW (and RX) ring
> * buffers for available descriptors but we don't need to trigger a
> * timer for that in qemu.
> */
> diff --git a/hw/net/i82596.c b/hw/net/i82596.c
> index fe9f2390a9..e5547fa3c2 100644
> --- a/hw/net/i82596.c
> +++ b/hw/net/i82596.c
> @@ -474,23 +474,23 @@ void i82596_h_reset(void *opaque)
> i82596_s_reset(s);
> }
>
> -int i82596_can_receive(NetClientState *nc)
> +bool i82596_can_receive(NetClientState *nc)
> {
> I82596State *s = qemu_get_nic_opaque(nc);
>
> if (s->rx_status == RX_SUSPENDED) {
> - return 0;
> + return false;
> }
>
> if (!s->lnkst) {
> - return 0;
> + return false;
> }
>
> if (USE_TIMER && !timer_pending(s->flush_queue_timer)) {
> - return 1;
> + return true;
> }
>
> - return 1;
> + return true;
> }
>
> #define MIN_BUF_SIZE 60
> diff --git a/hw/net/imx_fec.c b/hw/net/imx_fec.c
> index 6a124a154a..5dec813d6d 100644
> --- a/hw/net/imx_fec.c
> +++ b/hw/net/imx_fec.c
> @@ -1047,11 +1047,11 @@ static void imx_eth_write(void *opaque, hwaddr offset, uint64_t value,
> imx_eth_update(s);
> }
>
> -static int imx_eth_can_receive(NetClientState *nc)
> +static bool imx_eth_can_receive(NetClientState *nc)
> {
> IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
>
> FEC_PRINTF("\n");
>
> return !!s->regs[ENET_RDAR];
> }
> diff --git a/hw/net/opencores_eth.c b/hw/net/opencores_eth.c
> index 6b338c2f29..2ba0dc8c2f 100644
> --- a/hw/net/opencores_eth.c
> +++ b/hw/net/opencores_eth.c
> @@ -349,12 +349,11 @@ static void open_eth_reset(void *opaque)
> open_eth_set_link_status(qemu_get_queue(s->nic));
> }
>
> -static int open_eth_can_receive(NetClientState *nc)
> +static bool open_eth_can_receive(NetClientState *nc)
> {
> OpenEthState *s = qemu_get_nic_opaque(nc);
>
> - return GET_REGBIT(s, MODER, RXEN) &&
> - (s->regs[TX_BD_NUM] < 0x80);
> + return GET_REGBIT(s, MODER, RXEN) && (s->regs[TX_BD_NUM] < 0x80);
> }
>
> static ssize_t open_eth_receive(NetClientState *nc,
> diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c
> index be9a0af629..70aca7ec26 100644
> --- a/hw/net/rtl8139.c
> +++ b/hw/net/rtl8139.c
> @@ -793,26 +793,26 @@ static bool rtl8139_cp_rx_valid(RTL8139State *s)
> return !(s->RxRingAddrLO == 0 && s->RxRingAddrHI == 0);
> }
>
> -static int rtl8139_can_receive(NetClientState *nc)
> +static bool rtl8139_can_receive(NetClientState *nc)
> {
> RTL8139State *s = qemu_get_nic_opaque(nc);
> int avail;
>
> /* Receive (drop) packets if card is disabled. */
> if (!s->clock_enabled) {
> - return 1;
> + return true;
> }
> if (!rtl8139_receiver_enabled(s)) {
> - return 1;
> + return true;
> }
>
> if (rtl8139_cp_receiver_enabled(s) && rtl8139_cp_rx_valid(s)) {
> /* ??? Flow control not implemented in c+ mode.
> This is a hack to work around slirp deficiencies anyway. */
> - return 1;
> + return true;
> }
>
> avail = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr,
> s->RxBufferSize);
> return avail == 0 || avail >= 1514 || (s->IntrMask & RxOverflow);
> }
> diff --git a/hw/net/smc91c111.c b/hw/net/smc91c111.c
> index 02be60c955..b3240b9335 100644
> --- a/hw/net/smc91c111.c
> +++ b/hw/net/smc91c111.c
> @@ -667,9 +667,9 @@ static void smc91c111_writefn(void *opaque, hwaddr addr,
> }
> }
>
> -static int smc91c111_can_receive_nc(NetClientState *nc)
> +static bool smc91c111_can_receive_nc(NetClientState *nc)
> {
> smc91c111_state *s = qemu_get_nic_opaque(nc);
>
> return smc91c111_can_receive(s);
> }
> diff --git a/hw/net/spapr_llan.c b/hw/net/spapr_llan.c
> index 80f5a1dd37..a2377025a7 100644
> --- a/hw/net/spapr_llan.c
> +++ b/hw/net/spapr_llan.c
> @@ -110,17 +110,17 @@ typedef struct SpaprVioVlan {
> RxBufPool *rx_pool[RX_MAX_POOLS]; /* Receive buffer descriptor pools */
> } SpaprVioVlan;
>
> -static int spapr_vlan_can_receive(NetClientState *nc)
> +static bool spapr_vlan_can_receive(NetClientState *nc)
> {
> SpaprVioVlan *dev = qemu_get_nic_opaque(nc);
>
> - return (dev->isopen && dev->rx_bufs > 0);
> + return dev->isopen && dev->rx_bufs > 0;
> }
>
> /**
> * The last 8 bytes of the receive buffer list page (that has been
> * supplied by the guest with the H_REGISTER_LOGICAL_LAN call) contain
> * a counter for frames that have been dropped because there was no
> * suitable receive buffer available. This function is used to increase
> * this counter by one.
> */
> diff --git a/hw/net/sungem.c b/hw/net/sungem.c
> index 89da51f7f6..b01197d952 100644
> --- a/hw/net/sungem.c
> +++ b/hw/net/sungem.c
> @@ -433,31 +433,31 @@ static bool sungem_rx_full(SunGEMState *s, uint32_t kick, uint32_t done)
> return kick == ((done + 1) & s->rx_mask);
> }
>
> -static int sungem_can_receive(NetClientState *nc)
> +static bool sungem_can_receive(NetClientState *nc)
> {
> SunGEMState *s = qemu_get_nic_opaque(nc);
> uint32_t kick, done, rxdma_cfg, rxmac_cfg;
> bool full;
>
> rxmac_cfg = s->macregs[MAC_RXCFG >> 2];
> rxdma_cfg = s->rxdmaregs[RXDMA_CFG >> 2];
>
> /* If MAC disabled, can't receive */
> if ((rxmac_cfg & MAC_RXCFG_ENAB) == 0) {
> trace_sungem_rx_mac_disabled();
> - return 0;
> + return false;
> }
> if ((rxdma_cfg & RXDMA_CFG_ENABLE) == 0) {
> trace_sungem_rx_txdma_disabled();
> - return 0;
> + return false;
> }
>
> /* Check RX availability */
> kick = s->rxdmaregs[RXDMA_KICK >> 2];
> done = s->rxdmaregs[RXDMA_DONE >> 2];
> full = sungem_rx_full(s, kick, done);
>
> trace_sungem_rx_check(!full, kick, done);
>
> return !full;
> }
> diff --git a/hw/net/sunhme.c b/hw/net/sunhme.c
> index 8863601f6c..9c38583180 100644
> --- a/hw/net/sunhme.c
> +++ b/hw/net/sunhme.c
> @@ -657,11 +657,11 @@ static void sunhme_transmit(SunHMEState *s)
> sunhme_update_irq(s);
> }
>
> -static int sunhme_can_receive(NetClientState *nc)
> +static bool sunhme_can_receive(NetClientState *nc)
> {
> SunHMEState *s = qemu_get_nic_opaque(nc);
>
> - return s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_ENABLE;
> + return !!(s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_ENABLE);
> }
>
> static void sunhme_link_status_changed(NetClientState *nc)
> diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
> index 3627bb1717..a46e3b37a7 100644
> --- a/hw/net/virtio-net.c
> +++ b/hw/net/virtio-net.c
> @@ -1234,26 +1234,26 @@ static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
> qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
> }
>
> -static int virtio_net_can_receive(NetClientState *nc)
> +static bool virtio_net_can_receive(NetClientState *nc)
> {
> VirtIONet *n = qemu_get_nic_opaque(nc);
> VirtIODevice *vdev = VIRTIO_DEVICE(n);
> VirtIONetQueue *q = virtio_net_get_subqueue(nc);
>
> if (!vdev->vm_running) {
> - return 0;
> + return false;
> }
>
> if (nc->queue_index >= n->curr_queues) {
> - return 0;
> + return false;
> }
>
> if (!virtio_queue_ready(q->rx_vq) ||
> !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
> - return 0;
> + return false;
> }
>
> - return 1;
> + return true;
> }
>
> static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
> diff --git a/hw/net/xilinx_ethlite.c b/hw/net/xilinx_ethlite.c
> index cf07e698b3..71d16fef3d 100644
> --- a/hw/net/xilinx_ethlite.c
> +++ b/hw/net/xilinx_ethlite.c
> @@ -175,10 +175,10 @@ static const MemoryRegionOps eth_ops = {
> }
> };
>
> -static int eth_can_rx(NetClientState *nc)
> +static bool eth_can_rx(NetClientState *nc)
> {
> struct xlx_ethlite *s = qemu_get_nic_opaque(nc);
> unsigned int rxbase = s->rxbuf * (0x800 / 4);
>
> return !(s->regs[rxbase + R_RX_CTRL0] & CTRL_S);
> }
> diff --git a/net/filter-buffer.c b/net/filter-buffer.c
> index 88da78f821..12e0254287 100644
> --- a/net/filter-buffer.c
> +++ b/net/filter-buffer.c
> @@ -59,28 +59,28 @@ static void filter_buffer_release_timer(void *opaque)
> /* filter APIs */
> static ssize_t filter_buffer_receive_iov(NetFilterState *nf,
> NetClientState *sender,
> unsigned flags,
> const struct iovec *iov,
> int iovcnt,
> NetPacketSent *sent_cb)
> {
> FilterBufferState *s = FILTER_BUFFER(nf);
>
> /*
> * We return size when buffer a packet, the sender will take it as
> * a already sent packet, so sent_cb should not be called later.
> *
> * FIXME: Even if the guest can't receive packets for some reasons,
> * the filter can still accept packets until its internal queue is full.
> * For example:
> * For some reason, receiver could not receive more packets
> - * (.can_receive() returns zero). Without a filter, at most one packet
> + * (.can_receive() returns false). Without a filter, at most one packet
> * will be queued in incoming queue and sender's poll will be disabled
> * unit its sent_cb() was called. With a filter, it will keep receiving
> * the packets without caring about the receiver. This is suboptimal.
> * May need more thoughts (e.g keeping sent_cb).
> */
> qemu_net_queue_append_iov(s->incoming_queue, sender, flags,
> iov, iovcnt, NULL);
> return iov_size(iov, iovcnt);
> }
> diff --git a/net/hub.c b/net/hub.c
> index 5795a678ed..e7de173171 100644
> --- a/net/hub.c
> +++ b/net/hub.c
> @@ -90,23 +90,23 @@ static NetHub *net_hub_new(int id)
> return hub;
> }
>
> -static int net_hub_port_can_receive(NetClientState *nc)
> +static bool net_hub_port_can_receive(NetClientState *nc)
> {
> NetHubPort *port;
> NetHubPort *src_port = DO_UPCAST(NetHubPort, nc, nc);
> NetHub *hub = src_port->hub;
>
> QLIST_FOREACH(port, &hub->ports, next) {
> if (port == src_port) {
> continue;
> }
>
> if (qemu_can_send_packet(&port->nc)) {
> - return 1;
> + return true;
> }
> }
>
> - return 0;
> + return false;
> }
>
> static ssize_t net_hub_port_receive(NetClientState *nc,
> --
> 2.21.1
>
>
On 3/5/20 6:56 PM, Philippe Mathieu-Daudé wrote:
> The NetCanReceive handler return whether the device can or
> can not receive new packets. Make it obvious by returning
> a boolean type.
>
> Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
ftgmac100 looks good.
Reviewed-by: Cédric Le Goater <clg@kaod.org>
Thanks,
C.
> ---
> hw/net/i82596.h | 2 +-
> include/net/net.h | 2 +-
> hw/net/allwinner_emac.c | 2 +-
> hw/net/cadence_gem.c | 8 ++++----
> hw/net/dp8393x.c | 8 +++-----
> hw/net/e1000.c | 2 +-
> hw/net/e1000e.c | 2 +-
> hw/net/ftgmac100.c | 6 +++---
> hw/net/i82596.c | 10 +++++-----
> hw/net/imx_fec.c | 2 +-
> hw/net/opencores_eth.c | 5 ++---
> hw/net/rtl8139.c | 8 ++++----
> hw/net/smc91c111.c | 2 +-
> hw/net/spapr_llan.c | 4 ++--
> hw/net/sungem.c | 6 +++---
> hw/net/sunhme.c | 4 ++--
> hw/net/virtio-net.c | 10 +++++-----
> hw/net/xilinx_ethlite.c | 2 +-
> net/filter-buffer.c | 2 +-
> net/hub.c | 6 +++---
> 20 files changed, 45 insertions(+), 48 deletions(-)
>
> diff --git a/hw/net/i82596.h b/hw/net/i82596.h
> index 1238ac11f8..f0bbe810eb 100644
> --- a/hw/net/i82596.h
> +++ b/hw/net/i82596.h
> @@ -48,7 +48,7 @@ void i82596_ioport_writel(void *opaque, uint32_t addr, uint32_t val);
> uint32_t i82596_ioport_readl(void *opaque, uint32_t addr);
> uint32_t i82596_bcr_readw(I82596State *s, uint32_t rap);
> ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t size_);
> -int i82596_can_receive(NetClientState *nc);
> +bool i82596_can_receive(NetClientState *nc);
> void i82596_set_link_status(NetClientState *nc);
> void i82596_common_init(DeviceState *dev, I82596State *s, NetClientInfo *info);
> extern const VMStateDescription vmstate_i82596;
> diff --git a/include/net/net.h b/include/net/net.h
> index e175ba9677..d191ee777e 100644
> --- a/include/net/net.h
> +++ b/include/net/net.h
> @@ -42,7 +42,7 @@ typedef struct NICConf {
> /* Net clients */
>
> typedef void (NetPoll)(NetClientState *, bool enable);
> -typedef int (NetCanReceive)(NetClientState *);
> +typedef bool (NetCanReceive)(NetClientState *);
> typedef ssize_t (NetReceive)(NetClientState *, const uint8_t *, size_t);
> typedef ssize_t (NetReceiveIOV)(NetClientState *, const struct iovec *, int);
> typedef void (NetCleanup) (NetClientState *);
> diff --git a/hw/net/allwinner_emac.c b/hw/net/allwinner_emac.c
> index e9bbff8710..ddddf35c45 100644
> --- a/hw/net/allwinner_emac.c
> +++ b/hw/net/allwinner_emac.c
> @@ -178,13 +178,13 @@ static uint32_t fifo8_pop_word(Fifo8 *fifo)
> return ret;
> }
>
> -static int aw_emac_can_receive(NetClientState *nc)
> +static bool aw_emac_can_receive(NetClientState *nc)
> {
> AwEmacState *s = qemu_get_nic_opaque(nc);
>
> /*
> * To avoid packet drops, allow reception only when there is space
> * for a full frame: 1522 + 8 (rx headers) + 2 (padding).
> */
> return (s->ctl & EMAC_CTL_RX_EN) && (fifo8_num_free(&s->rx_fifo) >= 1532);
> }
> diff --git a/hw/net/cadence_gem.c b/hw/net/cadence_gem.c
> index 6340c1eaf8..51ec5a072d 100644
> --- a/hw/net/cadence_gem.c
> +++ b/hw/net/cadence_gem.c
> @@ -505,44 +505,44 @@ static void phy_update_link(CadenceGEMState *s)
> }
> }
>
> -static int gem_can_receive(NetClientState *nc)
> +static bool gem_can_receive(NetClientState *nc)
> {
> CadenceGEMState *s;
> int i;
>
> s = qemu_get_nic_opaque(nc);
>
> /* Do nothing if receive is not enabled. */
> if (!(s->regs[GEM_NWCTRL] & GEM_NWCTRL_RXENA)) {
> if (s->can_rx_state != 1) {
> s->can_rx_state = 1;
> DB_PRINT("can't receive - no enable\n");
> }
> - return 0;
> + return false;
> }
>
> for (i = 0; i < s->num_priority_queues; i++) {
> if (rx_desc_get_ownership(s->rx_desc[i]) != 1) {
> break;
> }
> };
>
> if (i == s->num_priority_queues) {
> if (s->can_rx_state != 2) {
> s->can_rx_state = 2;
> DB_PRINT("can't receive - all the buffer descriptors are busy\n");
> }
> - return 0;
> + return false;
> }
>
> if (s->can_rx_state != 0) {
> s->can_rx_state = 0;
> DB_PRINT("can receive\n");
> }
> - return 1;
> + return true;
> }
>
> /*
> * gem_update_int_status:
> * Raise or lower interrupt based on current status.
> */
> diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c
> index 8a3504d962..900ba5ca65 100644
> --- a/hw/net/dp8393x.c
> +++ b/hw/net/dp8393x.c
> @@ -414,7 +414,7 @@ static void dp8393x_do_stop_timer(dp8393xState *s)
> dp8393x_update_wt_regs(s);
> }
>
> -static int dp8393x_can_receive(NetClientState *nc);
> +static bool dp8393x_can_receive(NetClientState *nc);
>
> static void dp8393x_do_receiver_enable(dp8393xState *s)
> {
> @@ -718,13 +718,11 @@ static void dp8393x_watchdog(void *opaque)
> dp8393x_update_irq(s);
> }
>
> -static int dp8393x_can_receive(NetClientState *nc)
> +static bool dp8393x_can_receive(NetClientState *nc)
> {
> dp8393xState *s = qemu_get_nic_opaque(nc);
>
> - if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN))
> - return 0;
> - return 1;
> + return !!(s->regs[SONIC_CR] & SONIC_CR_RXEN);
> }
>
> static int dp8393x_receive_filter(dp8393xState *s, const uint8_t * buf,
> diff --git a/hw/net/e1000.c b/hw/net/e1000.c
> index 0b833d5a15..6b89df8f0a 100644
> --- a/hw/net/e1000.c
> +++ b/hw/net/e1000.c
> @@ -845,7 +845,7 @@ static bool e1000_has_rxbufs(E1000State *s, size_t total_size)
> return total_size <= bufs * s->rxbuf_size;
> }
>
> -static int
> +static bool
> e1000_can_receive(NetClientState *nc)
> {
> E1000State *s = qemu_get_nic_opaque(nc);
> diff --git a/hw/net/e1000e.c b/hw/net/e1000e.c
> index a91dbdca3c..f49fa1c7b1 100644
> --- a/hw/net/e1000e.c
> +++ b/hw/net/e1000e.c
> @@ -199,7 +199,7 @@ static const MemoryRegionOps io_ops = {
> },
> };
>
> -static int
> +static bool
> e1000e_nc_can_receive(NetClientState *nc)
> {
> E1000EState *s = qemu_get_nic_opaque(nc);
> diff --git a/hw/net/ftgmac100.c b/hw/net/ftgmac100.c
> index 2f92b65d4e..041ed21017 100644
> --- a/hw/net/ftgmac100.c
> +++ b/hw/net/ftgmac100.c
> @@ -562,24 +562,24 @@ static void ftgmac100_do_tx(FTGMAC100State *s, uint32_t tx_ring,
> ftgmac100_update_irq(s);
> }
>
> -static int ftgmac100_can_receive(NetClientState *nc)
> +static bool ftgmac100_can_receive(NetClientState *nc)
> {
> FTGMAC100State *s = FTGMAC100(qemu_get_nic_opaque(nc));
> FTGMAC100Desc bd;
>
> if ((s->maccr & (FTGMAC100_MACCR_RXDMA_EN | FTGMAC100_MACCR_RXMAC_EN))
> != (FTGMAC100_MACCR_RXDMA_EN | FTGMAC100_MACCR_RXMAC_EN)) {
> - return 0;
> + return false;
> }
>
> if (ftgmac100_read_bd(&bd, s->rx_descriptor)) {
> - return 0;
> + return false;
> }
> return !(bd.des0 & FTGMAC100_RXDES0_RXPKT_RDY);
> }
>
> /*
> * This is purely informative. The HW can poll the RW (and RX) ring
> * buffers for available descriptors but we don't need to trigger a
> * timer for that in qemu.
> */
> diff --git a/hw/net/i82596.c b/hw/net/i82596.c
> index fe9f2390a9..e5547fa3c2 100644
> --- a/hw/net/i82596.c
> +++ b/hw/net/i82596.c
> @@ -474,23 +474,23 @@ void i82596_h_reset(void *opaque)
> i82596_s_reset(s);
> }
>
> -int i82596_can_receive(NetClientState *nc)
> +bool i82596_can_receive(NetClientState *nc)
> {
> I82596State *s = qemu_get_nic_opaque(nc);
>
> if (s->rx_status == RX_SUSPENDED) {
> - return 0;
> + return false;
> }
>
> if (!s->lnkst) {
> - return 0;
> + return false;
> }
>
> if (USE_TIMER && !timer_pending(s->flush_queue_timer)) {
> - return 1;
> + return true;
> }
>
> - return 1;
> + return true;
> }
>
> #define MIN_BUF_SIZE 60
> diff --git a/hw/net/imx_fec.c b/hw/net/imx_fec.c
> index 6a124a154a..5dec813d6d 100644
> --- a/hw/net/imx_fec.c
> +++ b/hw/net/imx_fec.c
> @@ -1047,11 +1047,11 @@ static void imx_eth_write(void *opaque, hwaddr offset, uint64_t value,
> imx_eth_update(s);
> }
>
> -static int imx_eth_can_receive(NetClientState *nc)
> +static bool imx_eth_can_receive(NetClientState *nc)
> {
> IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
>
> FEC_PRINTF("\n");
>
> return !!s->regs[ENET_RDAR];
> }
> diff --git a/hw/net/opencores_eth.c b/hw/net/opencores_eth.c
> index 6b338c2f29..2ba0dc8c2f 100644
> --- a/hw/net/opencores_eth.c
> +++ b/hw/net/opencores_eth.c
> @@ -349,12 +349,11 @@ static void open_eth_reset(void *opaque)
> open_eth_set_link_status(qemu_get_queue(s->nic));
> }
>
> -static int open_eth_can_receive(NetClientState *nc)
> +static bool open_eth_can_receive(NetClientState *nc)
> {
> OpenEthState *s = qemu_get_nic_opaque(nc);
>
> - return GET_REGBIT(s, MODER, RXEN) &&
> - (s->regs[TX_BD_NUM] < 0x80);
> + return GET_REGBIT(s, MODER, RXEN) && (s->regs[TX_BD_NUM] < 0x80);
> }
>
> static ssize_t open_eth_receive(NetClientState *nc,
> diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c
> index be9a0af629..70aca7ec26 100644
> --- a/hw/net/rtl8139.c
> +++ b/hw/net/rtl8139.c
> @@ -793,26 +793,26 @@ static bool rtl8139_cp_rx_valid(RTL8139State *s)
> return !(s->RxRingAddrLO == 0 && s->RxRingAddrHI == 0);
> }
>
> -static int rtl8139_can_receive(NetClientState *nc)
> +static bool rtl8139_can_receive(NetClientState *nc)
> {
> RTL8139State *s = qemu_get_nic_opaque(nc);
> int avail;
>
> /* Receive (drop) packets if card is disabled. */
> if (!s->clock_enabled) {
> - return 1;
> + return true;
> }
> if (!rtl8139_receiver_enabled(s)) {
> - return 1;
> + return true;
> }
>
> if (rtl8139_cp_receiver_enabled(s) && rtl8139_cp_rx_valid(s)) {
> /* ??? Flow control not implemented in c+ mode.
> This is a hack to work around slirp deficiencies anyway. */
> - return 1;
> + return true;
> }
>
> avail = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr,
> s->RxBufferSize);
> return avail == 0 || avail >= 1514 || (s->IntrMask & RxOverflow);
> }
> diff --git a/hw/net/smc91c111.c b/hw/net/smc91c111.c
> index 02be60c955..b3240b9335 100644
> --- a/hw/net/smc91c111.c
> +++ b/hw/net/smc91c111.c
> @@ -667,9 +667,9 @@ static void smc91c111_writefn(void *opaque, hwaddr addr,
> }
> }
>
> -static int smc91c111_can_receive_nc(NetClientState *nc)
> +static bool smc91c111_can_receive_nc(NetClientState *nc)
> {
> smc91c111_state *s = qemu_get_nic_opaque(nc);
>
> return smc91c111_can_receive(s);
> }
> diff --git a/hw/net/spapr_llan.c b/hw/net/spapr_llan.c
> index 80f5a1dd37..a2377025a7 100644
> --- a/hw/net/spapr_llan.c
> +++ b/hw/net/spapr_llan.c
> @@ -110,17 +110,17 @@ typedef struct SpaprVioVlan {
> RxBufPool *rx_pool[RX_MAX_POOLS]; /* Receive buffer descriptor pools */
> } SpaprVioVlan;
>
> -static int spapr_vlan_can_receive(NetClientState *nc)
> +static bool spapr_vlan_can_receive(NetClientState *nc)
> {
> SpaprVioVlan *dev = qemu_get_nic_opaque(nc);
>
> - return (dev->isopen && dev->rx_bufs > 0);
> + return dev->isopen && dev->rx_bufs > 0;
> }
>
> /**
> * The last 8 bytes of the receive buffer list page (that has been
> * supplied by the guest with the H_REGISTER_LOGICAL_LAN call) contain
> * a counter for frames that have been dropped because there was no
> * suitable receive buffer available. This function is used to increase
> * this counter by one.
> */
> diff --git a/hw/net/sungem.c b/hw/net/sungem.c
> index 89da51f7f6..b01197d952 100644
> --- a/hw/net/sungem.c
> +++ b/hw/net/sungem.c
> @@ -433,31 +433,31 @@ static bool sungem_rx_full(SunGEMState *s, uint32_t kick, uint32_t done)
> return kick == ((done + 1) & s->rx_mask);
> }
>
> -static int sungem_can_receive(NetClientState *nc)
> +static bool sungem_can_receive(NetClientState *nc)
> {
> SunGEMState *s = qemu_get_nic_opaque(nc);
> uint32_t kick, done, rxdma_cfg, rxmac_cfg;
> bool full;
>
> rxmac_cfg = s->macregs[MAC_RXCFG >> 2];
> rxdma_cfg = s->rxdmaregs[RXDMA_CFG >> 2];
>
> /* If MAC disabled, can't receive */
> if ((rxmac_cfg & MAC_RXCFG_ENAB) == 0) {
> trace_sungem_rx_mac_disabled();
> - return 0;
> + return false;
> }
> if ((rxdma_cfg & RXDMA_CFG_ENABLE) == 0) {
> trace_sungem_rx_txdma_disabled();
> - return 0;
> + return false;
> }
>
> /* Check RX availability */
> kick = s->rxdmaregs[RXDMA_KICK >> 2];
> done = s->rxdmaregs[RXDMA_DONE >> 2];
> full = sungem_rx_full(s, kick, done);
>
> trace_sungem_rx_check(!full, kick, done);
>
> return !full;
> }
> diff --git a/hw/net/sunhme.c b/hw/net/sunhme.c
> index 8863601f6c..9c38583180 100644
> --- a/hw/net/sunhme.c
> +++ b/hw/net/sunhme.c
> @@ -657,11 +657,11 @@ static void sunhme_transmit(SunHMEState *s)
> sunhme_update_irq(s);
> }
>
> -static int sunhme_can_receive(NetClientState *nc)
> +static bool sunhme_can_receive(NetClientState *nc)
> {
> SunHMEState *s = qemu_get_nic_opaque(nc);
>
> - return s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_ENABLE;
> + return !!(s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_ENABLE);
> }
>
> static void sunhme_link_status_changed(NetClientState *nc)
> diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
> index 3627bb1717..a46e3b37a7 100644
> --- a/hw/net/virtio-net.c
> +++ b/hw/net/virtio-net.c
> @@ -1234,26 +1234,26 @@ static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
> qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
> }
>
> -static int virtio_net_can_receive(NetClientState *nc)
> +static bool virtio_net_can_receive(NetClientState *nc)
> {
> VirtIONet *n = qemu_get_nic_opaque(nc);
> VirtIODevice *vdev = VIRTIO_DEVICE(n);
> VirtIONetQueue *q = virtio_net_get_subqueue(nc);
>
> if (!vdev->vm_running) {
> - return 0;
> + return false;
> }
>
> if (nc->queue_index >= n->curr_queues) {
> - return 0;
> + return false;
> }
>
> if (!virtio_queue_ready(q->rx_vq) ||
> !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
> - return 0;
> + return false;
> }
>
> - return 1;
> + return true;
> }
>
> static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
> diff --git a/hw/net/xilinx_ethlite.c b/hw/net/xilinx_ethlite.c
> index cf07e698b3..71d16fef3d 100644
> --- a/hw/net/xilinx_ethlite.c
> +++ b/hw/net/xilinx_ethlite.c
> @@ -175,10 +175,10 @@ static const MemoryRegionOps eth_ops = {
> }
> };
>
> -static int eth_can_rx(NetClientState *nc)
> +static bool eth_can_rx(NetClientState *nc)
> {
> struct xlx_ethlite *s = qemu_get_nic_opaque(nc);
> unsigned int rxbase = s->rxbuf * (0x800 / 4);
>
> return !(s->regs[rxbase + R_RX_CTRL0] & CTRL_S);
> }
> diff --git a/net/filter-buffer.c b/net/filter-buffer.c
> index 88da78f821..12e0254287 100644
> --- a/net/filter-buffer.c
> +++ b/net/filter-buffer.c
> @@ -59,28 +59,28 @@ static void filter_buffer_release_timer(void *opaque)
> /* filter APIs */
> static ssize_t filter_buffer_receive_iov(NetFilterState *nf,
> NetClientState *sender,
> unsigned flags,
> const struct iovec *iov,
> int iovcnt,
> NetPacketSent *sent_cb)
> {
> FilterBufferState *s = FILTER_BUFFER(nf);
>
> /*
> * We return size when buffer a packet, the sender will take it as
> * a already sent packet, so sent_cb should not be called later.
> *
> * FIXME: Even if the guest can't receive packets for some reasons,
> * the filter can still accept packets until its internal queue is full.
> * For example:
> * For some reason, receiver could not receive more packets
> - * (.can_receive() returns zero). Without a filter, at most one packet
> + * (.can_receive() returns false). Without a filter, at most one packet
> * will be queued in incoming queue and sender's poll will be disabled
> * unit its sent_cb() was called. With a filter, it will keep receiving
> * the packets without caring about the receiver. This is suboptimal.
> * May need more thoughts (e.g keeping sent_cb).
> */
> qemu_net_queue_append_iov(s->incoming_queue, sender, flags,
> iov, iovcnt, NULL);
> return iov_size(iov, iovcnt);
> }
> diff --git a/net/hub.c b/net/hub.c
> index 5795a678ed..e7de173171 100644
> --- a/net/hub.c
> +++ b/net/hub.c
> @@ -90,23 +90,23 @@ static NetHub *net_hub_new(int id)
> return hub;
> }
>
> -static int net_hub_port_can_receive(NetClientState *nc)
> +static bool net_hub_port_can_receive(NetClientState *nc)
> {
> NetHubPort *port;
> NetHubPort *src_port = DO_UPCAST(NetHubPort, nc, nc);
> NetHub *hub = src_port->hub;
>
> QLIST_FOREACH(port, &hub->ports, next) {
> if (port == src_port) {
> continue;
> }
>
> if (qemu_can_send_packet(&port->nc)) {
> - return 1;
> + return true;
> }
> }
>
> - return 0;
> + return false;
> }
>
> static ssize_t net_hub_port_receive(NetClientState *nc,
>
© 2016 - 2025 Red Hat, Inc.