The following changes since commit cfe68ae025f704f336d7dd3d1903ce37b445831d:

Merge remote-tracking branch 'remotes/vivier2/tags/linux-user-for-5.0-pull-request' into staging (2020-03-26 20:55:54 +0000)

for you to fetch changes up to f3b364f4f77fcb24cec468f518bf5e093dc27cb7:

hw/net/allwinner-sun8i-emac.c: Fix REG_ADDR_HIGH/LOW reads (2020-03-27 18:59:47 +0800)

Andrew Melnychenko (1):

Fixed integer overflow in e1000e

Peter Maydell (2):

hw/net/i82596.c: Avoid reading off end of buffer in i82596_receive()

hw/net/allwinner-sun8i-emac.c: Fix REG_ADDR_HIGH/LOW reads

Philippe Mathieu-Daudé (7):

hw/net/i82596: Correct command bitmask (CID 1419392)

hw/net/e1000e_core: Let e1000e_can_receive() return a boolean

hw/net/smc91c111: Let smc91c111_can_receive() return a boolean

hw/net/rtl8139: Simplify if/else statement

hw/net/rtl8139: Update coding style to make checkpatch.pl happy

hw/net: Make NetCanReceive() return a boolean

hw/net/can: Make CanBusClientInfo::can_receive() return a boolean

Prasad J Pandit (1):

net: tulip: check frame size and r/w data length

net/colo-compare.c: Expose "compare_timeout" to users

net/colo-compare.c: Expose "expired_scan_cycle" to users

hw/net/allwinner-sun8i-emac.c | 12 ++----

hw/net/allwinner_emac.c | 2 +-

hw/net/cadence_gem.c | 8 ++--

hw/net/can/can_sja1000.c | 8 ++--

hw/net/can/can_sja1000.h | 2 +-

hw/net/dp8393x.c | 8 ++--

hw/net/e1000.c | 2 +-

hw/net/e1000e.c | 4 +-

hw/net/e1000e_core.c | 2 +-

hw/net/e1000e_core.h | 2 +-

hw/net/ftgmac100.c | 6 +--

hw/net/i82596.c | 66 ++++++++++++++++++++----------

hw/net/i82596.h | 2 +-

hw/net/imx_fec.c | 2 +-

hw/net/opencores_eth.c | 5 +--

hw/net/rtl8139.c | 22 +++++-----

hw/net/smc91c111.c | 10 ++---

hw/net/spapr_llan.c | 4 +-

hw/net/sungem.c | 6 +--

hw/net/sunhme.c | 4 +-

hw/net/tulip.c | 36 ++++++++++++----

hw/net/virtio-net.c | 10 ++---

hw/net/xilinx_ethlite.c | 2 +-

include/net/can_emu.h | 2 +-

include/net/net.h | 2 +-

net/can/can_socketcan.c | 4 +-

net/colo-compare.c | 95 ++++++++++++++++++++++++++++++++++++++++---

net/filter-buffer.c | 2 +-

net/hub.c | 6 +--

qemu-options.hx | 10 +++--

30 files changed, 235 insertions(+), 111 deletions(-)

The CanBusClientInfo::can_receive handler return whether the

device can or can not receive new frames. Make it obvious by

returning a boolean type.

hw/net/can/can_sja1000.c | 8 ++++----

hw/net/can/can_sja1000.h | 2 +-

include/net/can_emu.h | 2 +-

net/can/can_socketcan.c | 4 ++--

4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/hw/net/can/can_sja1000.c b/hw/net/can/can_sja1000.c

--- a/hw/net/can/can_sja1000.c

+++ b/hw/net/can/can_sja1000.c

@@ -XXX,XX +XXX,XX @@ uint64_t can_sja_mem_read(CanSJA1000State *s, hwaddr addr, unsigned size)

return temp;

}

-int can_sja_can_receive(CanBusClientState *client)

+bool can_sja_can_receive(CanBusClientState *client)

{

CanSJA1000State *s = container_of(client, CanSJA1000State, bus_client);

if (s->clock & 0x80) { /* PeliCAN Mode */

if (s->mode & 0x01) { /* reset mode. */

- return 0;

+ return false;

}

} else { /* BasicCAN mode */

if (s->control & 0x01) {

- return 0;

+ return false;

}

}

- return 1; /* always return 1, when operation mode */

+ return true; /* always return true, when operation mode */

}

ssize_t can_sja_receive(CanBusClientState *client, const qemu_can_frame *frames,

diff --git a/hw/net/can/can_sja1000.h b/hw/net/can/can_sja1000.h

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/can/can_sja1000.h

+++ b/hw/net/can/can_sja1000.h

@@ -XXX,XX +XXX,XX @@ void can_sja_disconnect(CanSJA1000State *s);

int can_sja_init(CanSJA1000State *s, qemu_irq irq);

-int can_sja_can_receive(CanBusClientState *client);

+bool can_sja_can_receive(CanBusClientState *client);

ssize_t can_sja_receive(CanBusClientState *client,

const qemu_can_frame *frames, size_t frames_cnt);

diff --git a/include/net/can_emu.h b/include/net/can_emu.h

index XXXXXXX..XXXXXXX 100644

--- a/include/net/can_emu.h

+++ b/include/net/can_emu.h

@@ -XXX,XX +XXX,XX @@ typedef struct CanBusClientState CanBusClientState;

typedef struct CanBusState CanBusState;

typedef struct CanBusClientInfo {

- int (*can_receive)(CanBusClientState *);

+ bool (*can_receive)(CanBusClientState *);

ssize_t (*receive)(CanBusClientState *,

const struct qemu_can_frame *frames, size_t frames_cnt);

} CanBusClientInfo;

diff --git a/net/can/can_socketcan.c b/net/can/can_socketcan.c

index XXXXXXX..XXXXXXX 100644

--- a/net/can/can_socketcan.c

+++ b/net/can/can_socketcan.c

@@ -XXX,XX +XXX,XX @@ static void can_host_socketcan_read(void *opaque)

}

}

-static int can_host_socketcan_can_receive(CanBusClientState *client)

+static bool can_host_socketcan_can_receive(CanBusClientState *client)

{

- return 1;

+ return true;

}

static ssize_t can_host_socketcan_receive(CanBusClientState *client,

2.5.0

From: Philippe Mathieu-Daudé <philmd@redhat.com>

We will modify this code in the next commit. Clean it up

first to avoid checkpatch.pl errors.

Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

Reviewed-by: Cédric Le Goater <clg@kaod.org>

hw/net/rtl8139.c | 10 ++++++----

1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c

--- a/hw/net/rtl8139.c

+++ b/hw/net/rtl8139.c

@@ -XXX,XX +XXX,XX @@ static int rtl8139_can_receive(NetClientState *nc)

int avail;

/* Receive (drop) packets if card is disabled. */

- if (!s->clock_enabled)

- return 1;

- if (!rtl8139_receiver_enabled(s))

- return 1;

+ if (!s->clock_enabled) {

+ return 1;

+ }

+ if (!rtl8139_receiver_enabled(s)) {

+ return 1;

+ }

if (rtl8139_cp_receiver_enabled(s) && rtl8139_cp_rx_valid(s)) {

/* ??? Flow control not implemented in c+ mode.

2.5.0

From: Peter Maydell <peter.maydell@linaro.org>

Coverity points out (CID 1421926) that the read code for

REG_ADDR_HIGH reads off the end of the buffer, because it does a

32-bit read from byte 4 of a 6-byte buffer.

The code also has an endianness issue for both REG_ADDR_HIGH and

REG_ADDR_LOW, because it will do the wrong thing on a big-endian

host.

Rewrite the read code to use ldl_le_p() and lduw_le_p() to fix this;

the write code is not incorrect, but for consistency we make it use

stl_le_p() and stw_le_p().

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Tested-by: Niek Linnenbank <nieklinnenbank@gmail.com>

Reviewed-by: Niek Linnenbank <nieklinnenbank@gmail.com>

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

hw/net/allwinner-sun8i-emac.c | 12 ++++--------

1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/hw/net/allwinner-sun8i-emac.c b/hw/net/allwinner-sun8i-emac.c

--- a/hw/net/allwinner-sun8i-emac.c

+++ b/hw/net/allwinner-sun8i-emac.c

@@ -XXX,XX +XXX,XX @@ static uint64_t allwinner_sun8i_emac_read(void *opaque, hwaddr offset,

value = s->mii_data;

break;

case REG_ADDR_HIGH: /* MAC Address High */

- value = *(((uint32_t *) (s->conf.macaddr.a)) + 1);

+ value = lduw_le_p(s->conf.macaddr.a + 4);

break;

case REG_ADDR_LOW: /* MAC Address Low */

- value = *(uint32_t *) (s->conf.macaddr.a);

+ value = ldl_le_p(s->conf.macaddr.a);

break;

case REG_TX_DMA_STA: /* Transmit DMA Status */

break;

@@ -XXX,XX +XXX,XX @@ static void allwinner_sun8i_emac_write(void *opaque, hwaddr offset,

s->mii_data = value;

break;

case REG_ADDR_HIGH: /* MAC Address High */

- s->conf.macaddr.a[4] = (value & 0xff);

- s->conf.macaddr.a[5] = (value & 0xff00) >> 8;

+ stw_le_p(s->conf.macaddr.a + 4, value);

break;

case REG_ADDR_LOW: /* MAC Address Low */

- s->conf.macaddr.a[0] = (value & 0xff);

- s->conf.macaddr.a[1] = (value & 0xff00) >> 8;

- s->conf.macaddr.a[2] = (value & 0xff0000) >> 16;

- s->conf.macaddr.a[3] = (value & 0xff000000) >> 24;

+ stl_le_p(s->conf.macaddr.a, value);

break;

case REG_TX_DMA_STA: /* Transmit DMA Status */

case REG_TX_CUR_DESC: /* Transmit Current Descriptor */

2.5.0

The "compare_timeout" determines the maximum time to hold the primary net packet.

This patch expose the "compare_timeout", make user have ability to

adjest the value according to application scenarios.

QMP command demo:

{ "execute": "qom-get",

"arguments": { "path": "/objects/comp0",

"property": "compare_timeout" } }

{ "execute": "qom-set",

"arguments": { "path": "/objects/comp0",

"property": "compare_timeout",

"value": 5000} }

net/colo-compare.c | 47 +++++++++++++++++++++++++++++++++++++++++++++--

qemu-options.hx | 8 +++++---

2 files changed, 50 insertions(+), 5 deletions(-)

@@ -XXX,XX +XXX,XX @@ static NotifierList colo_compare_notifiers =

/* TODO: Should be configurable */

#define REGULAR_PACKET_CHECK_MS 3000

+#define DEFAULT_TIME_OUT_MS 3000

static QemuMutex event_mtx;

static QemuCond event_complete_cond;

@@ -XXX,XX +XXX,XX @@ typedef struct CompareState {

SocketReadState sec_rs;

SocketReadState notify_rs;

bool vnet_hdr;

+ uint32_t compare_timeout;

/*

* Record the connection that through the NIC

@@ -XXX,XX +XXX,XX @@ static int colo_old_packet_check_one_conn(Connection *conn,

CompareState *s)

GList *result = NULL;

- int64_t check_time = REGULAR_PACKET_CHECK_MS;

result = g_queue_find_custom(&conn->primary_list,

- &check_time,

+ &s->compare_timeout,

(GCompareFunc)colo_old_packet_check_one);

if (result) {

@@ -XXX,XX +XXX,XX @@ static void compare_set_notify_dev(Object *obj, const char *value, Error **errp)

s->notify_dev = g_strdup(value);

+static void compare_get_timeout(Object *obj, Visitor *v,

+ const char *name, void *opaque,

+ Error **errp)

+{

+ CompareState *s = COLO_COMPARE(obj);

+ uint32_t value = s->compare_timeout;

+

+ visit_type_uint32(v, name, &value, errp);

+}

+

+static void compare_set_timeout(Object *obj, Visitor *v,

+ const char *name, void *opaque,

+ Error **errp)

+{

+ CompareState *s = COLO_COMPARE(obj);

+ Error *local_err = NULL;

+ uint32_t value;

+

+ visit_type_uint32(v, name, &value, &local_err);

+ if (local_err) {

+ goto out;

+ }

+ if (!value) {

+ error_setg(&local_err, "Property '%s.%s' requires a positive value",

+ object_get_typename(obj), name);

+ goto out;

+ }

+ s->compare_timeout = value;

+

+out:

+ error_propagate(errp, local_err);

+}

+

static void compare_pri_rs_finalize(SocketReadState *pri_rs)

{

CompareState *s = container_of(pri_rs, CompareState, pri_rs);

@@ -XXX,XX +XXX,XX @@ static void colo_compare_complete(UserCreatable *uc, Error **errp)

+ if (!s->compare_timeout) {

+ /* Set default value to 3000 MS */

+ s->compare_timeout = DEFAULT_TIME_OUT_MS;

+ }

+

if (find_and_check_chardev(&chr, s->pri_indev, errp) ||

!qemu_chr_fe_init(&s->chr_pri_in, chr, errp)) {

@@ -XXX,XX +XXX,XX @@ static void colo_compare_init(Object *obj)

compare_get_notify_dev, compare_set_notify_dev,

NULL);

+ object_property_add(obj, "compare_timeout", "uint32",

+ compare_get_timeout,

+ compare_set_timeout, NULL, NULL, NULL);

+

s->vnet_hdr = false;

object_property_add_bool(obj, "vnet_hdr_support", compare_get_vnet_hdr,

compare_set_vnet_hdr, NULL);

diff --git a/qemu-options.hx b/qemu-options.hx

index XXXXXXX..XXXXXXX 100644

--- a/qemu-options.hx

+++ b/qemu-options.hx

@@ -XXX,XX +XXX,XX @@ SRST

stored. The file format is libpcap, so it can be analyzed with

tools such as tcpdump or Wireshark.

- ``-object colo-compare,id=id,primary_in=chardevid,secondary_in=chardevid,outdev=chardevid,iothread=id[,vnet_hdr_support][,notify_dev=id]``

+ ``-object colo-compare,id=id,primary_in=chardevid,secondary_in=chardevid,outdev=chardevid,iothread=id[,vnet_hdr_support][,notify_dev=id][,compare_timeout=@var{ms}]``

Colo-compare gets packet from primary\_inchardevid and

secondary\_inchardevid, than compare primary packet with

secondary packet. If the packets are same, we will output

@@ -XXX,XX +XXX,XX @@ SRST

outdevchardevid. In order to improve efficiency, we need to put

the task of comparison in another thread. If it has the

vnet\_hdr\_support flag, colo compare will send/recv packet with

- vnet\_hdr\_len. If you want to use Xen COLO, will need the

- notify\_dev to notify Xen colo-frame to do checkpoint.

+ vnet\_hdr\_len. Then compare\_timeout=@var{ms} determines the

+ maximum delay colo-compare wait for the packet.

+ If you want to use Xen COLO, will need the notify\_dev to

+ notify Xen colo-frame to do checkpoint.

we must use it with the help of filter-mirror and

filter-redirector.

2.5.0

The "expired_scan_cycle" determines period of scanning expired

primary node net packets.

net/colo-compare.c | 48 +++++++++++++++++++++++++++++++++++++++++++++---

qemu-options.hx | 4 +++-

2 files changed, 48 insertions(+), 4 deletions(-)

+ if (!s->expired_scan_cycle) {

+ /* Set default value to 3000 MS */

+ s->expired_scan_cycle = REGULAR_PACKET_CHECK_MS;

+ }

+

if (find_and_check_chardev(&chr, s->pri_indev, errp) ||

!qemu_chr_fe_init(&s->chr_pri_in, chr, errp)) {

return;

@@ -XXX,XX +XXX,XX @@ static void colo_compare_init(Object *obj)

compare_get_timeout,

compare_set_timeout, NULL, NULL, NULL);

+ object_property_add(obj, "expired_scan_cycle", "uint32",

+ compare_get_expired_scan_cycle,

+ compare_set_expired_scan_cycle, NULL, NULL, NULL);

+

s->vnet_hdr = false;

object_property_add_bool(obj, "vnet_hdr_support", compare_get_vnet_hdr,

compare_set_vnet_hdr, NULL);

diff --git a/qemu-options.hx b/qemu-options.hx

index XXXXXXX..XXXXXXX 100644

--- a/qemu-options.hx

+++ b/qemu-options.hx

@@ -XXX,XX +XXX,XX @@ SRST

stored. The file format is libpcap, so it can be analyzed with

tools such as tcpdump or Wireshark.

- ``-object colo-compare,id=id,primary_in=chardevid,secondary_in=chardevid,outdev=chardevid,iothread=id[,vnet_hdr_support][,notify_dev=id][,compare_timeout=@var{ms}]``

+ ``-object colo-compare,id=id,primary_in=chardevid,secondary_in=chardevid,outdev=chardevid,iothread=id[,vnet_hdr_support][,notify_dev=id][,compare_timeout=@var{ms}][,expired_scan_cycle=@var{ms}``

Colo-compare gets packet from primary\_inchardevid and

secondary\_inchardevid, than compare primary packet with

secondary packet. If the packets are same, we will output

@@ -XXX,XX +XXX,XX @@ SRST

vnet\_hdr\_support flag, colo compare will send/recv packet with

vnet\_hdr\_len. Then compare\_timeout=@var{ms} determines the

maximum delay colo-compare wait for the packet.

+ The expired\_scan\_cycle=@var{ms} to set the period of scanning

+ expired primary node network packets.

If you want to use Xen COLO, will need the notify\_dev to

notify Xen colo-frame to do checkpoint.

2.5.0

From: Philippe Mathieu-Daudé <philmd@redhat.com>

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>

Acked-by: David Gibson <david@gibson.dropbear.id.au>

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

Reviewed-by: Cédric Le Goater <clg@kaod.org>

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/i82596.h | 2 +-

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 +-

include/net/net.h | 2 +-

net/filter-buffer.c | 2 +-

net/hub.c | 6 +++---

20 files changed, 45 insertions(+), 48 deletions(-)

diff --git a/hw/net/allwinner_emac.c b/hw/net/allwinner_emac.c

--- a/hw/net/allwinner_emac.c

+++ b/hw/net/allwinner_emac.c

@@ -XXX,XX +XXX,XX @@ 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);

diff --git a/hw/net/cadence_gem.c b/hw/net/cadence_gem.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/cadence_gem.c

+++ b/hw/net/cadence_gem.c

@@ -XXX,XX +XXX,XX @@ 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;

@@ -XXX,XX +XXX,XX @@ static int gem_can_receive(NetClientState *nc)

s->can_rx_state = 1;

DB_PRINT("can't receive - no enable\n");

}

+ return false;

}

for (i = 0; i < s->num_priority_queues; i++) {

@@ -XXX,XX +XXX,XX @@ static int gem_can_receive(NetClientState *nc)

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;

}

/*

diff --git a/hw/net/dp8393x.c b/hw/net/dp8393x.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/dp8393x.c

+++ b/hw/net/dp8393x.c

@@ -XXX,XX +XXX,XX @@ 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)

{

@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644

--- a/hw/net/e1000.c

+++ b/hw/net/e1000.c

@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644

--- a/hw/net/e1000e.c

+++ b/hw/net/e1000e.c

@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644

--- a/hw/net/ftgmac100.c

+++ b/hw/net/ftgmac100.c

@@ -XXX,XX +XXX,XX @@ 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);

}

diff --git a/hw/net/i82596.c b/hw/net/i82596.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/i82596.c

+++ b/hw/net/i82596.c

@@ -XXX,XX +XXX,XX @@ 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/i82596.h b/hw/net/i82596.h

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/i82596.h

+++ b/hw/net/i82596.h

@@ -XXX,XX +XXX,XX @@ 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/hw/net/imx_fec.c b/hw/net/imx_fec.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/imx_fec.c

+++ b/hw/net/imx_fec.c

@@ -XXX,XX +XXX,XX @@ 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));

diff --git a/hw/net/opencores_eth.c b/hw/net/opencores_eth.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/opencores_eth.c

+++ b/hw/net/opencores_eth.c

@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644

--- a/hw/net/rtl8139.c

+++ b/hw/net/rtl8139.c

@@ -XXX,XX +XXX,XX @@ 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,

diff --git a/hw/net/smc91c111.c b/hw/net/smc91c111.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/smc91c111.c

+++ b/hw/net/smc91c111.c

@@ -XXX,XX +XXX,XX @@ 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);

diff --git a/hw/net/spapr_llan.c b/hw/net/spapr_llan.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/spapr_llan.c

+++ b/hw/net/spapr_llan.c

@@ -XXX,XX +XXX,XX @@ 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;

}

/**

diff --git a/hw/net/sungem.c b/hw/net/sungem.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/sungem.c

+++ b/hw/net/sungem.c

@@ -XXX,XX +XXX,XX @@ 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;

@@ -XXX,XX +XXX,XX @@ static int sungem_can_receive(NetClientState *nc)

/* 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 */

diff --git a/hw/net/sunhme.c b/hw/net/sunhme.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/net/sunhme.c

+++ b/hw/net/sunhme.c

@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644

--- a/hw/net/virtio-net.c

+++ b/hw/net/virtio-net.c

@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644

--- a/hw/net/xilinx_ethlite.c

+++ b/hw/net/xilinx_ethlite.c

@@ -XXX,XX +XXX,XX @@ 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);

diff --git a/include/net/net.h b/include/net/net.h

index XXXXXXX..XXXXXXX 100644

--- a/include/net/net.h

+++ b/include/net/net.h

@@ -XXX,XX +XXX,XX @@ 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/net/filter-buffer.c b/net/filter-buffer.c

index XXXXXXX..XXXXXXX 100644

--- a/net/filter-buffer.c

+++ b/net/filter-buffer.c

@@ -XXX,XX +XXX,XX @@ static ssize_t filter_buffer_receive_iov(NetFilterState *nf,

* 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.

diff --git a/net/hub.c b/net/hub.c

index XXXXXXX..XXXXXXX 100644

--- a/net/hub.c

+++ b/net/hub.c

@@ -XXX,XX +XXX,XX @@ 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);

@@ -XXX,XX +XXX,XX @@ static int net_hub_port_can_receive(NetClientState *nc)

}

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.5.0

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Rewrite:

if (E) {

return A;

} else {

return B;

}

/* EOF */

}

as:

if (E) {

return A;

}

return B;

}

Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

Reviewed-by: Cédric Le Goater <clg@kaod.org>

hw/net/rtl8139.c | 8 ++++----

1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c

--- a/hw/net/rtl8139.c

+++ b/hw/net/rtl8139.c

@@ -XXX,XX +XXX,XX @@ static int rtl8139_can_receive(NetClientState *nc)

/* ??? Flow control not implemented in c+ mode.

This is a hack to work around slirp deficiencies anyway. */

return 1;

- } else {

- avail = MOD2(s->RxBufferSize + s->RxBufPtr - s->RxBufAddr,