From: Anthony Liguori <anthony@codemonkey.ws>
To: qemu-devel@nongnu.org
Cc: Blue Swirl <blauwirbel@gmail.com>
Subject: Re: [Qemu-devel] [5274] Add signed versions of save/load functions
Date: Thu, 25 Sep 2008 13:23:03 -0500 [thread overview]
Message-ID: <48DBD707.4040806@codemonkey.ws> (raw)
In-Reply-To: <E1KgxRs-0002UK-Ch@cvs.savannah.gnu.org>
Blue Swirl wrote:
> Revision: 5274
> http://svn.sv.gnu.org/viewvc/?view=rev&root=qemu&revision=5274
> Author: blueswir1
> Date: 2008-09-20 08:04:11 +0000 (Sat, 20 Sep 2008)
>
Hi Blue Swirl,
I just noticed save/restore is broken for target-i386 and I bisected to
this commit. I'm going to start looking into what's broken but wanted
to let you know in case you had an idea.
Regards,
Anthony Liguori
> Log Message:
> -----------
> Add signed versions of save/load functions
>
> Modified Paths:
> --------------
> trunk/hw/e1000.c
> trunk/hw/esp.c
> trunk/hw/hw.h
> trunk/hw/pcnet.c
> trunk/hw/ptimer.c
> trunk/hw/pxa2xx.c
> trunk/hw/pxa2xx_timer.c
> trunk/hw/tcx.c
> trunk/hw/tmp105.c
> trunk/hw/tsc210x.c
> trunk/target-i386/machine.c
> trunk/vl.c
>
> Modified: trunk/hw/e1000.c
> ===================================================================
> --- trunk/hw/e1000.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/e1000.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -102,8 +102,8 @@
> uint32_t paylen;
> uint16_t tso_frames;
> char tse;
> - char ip;
> - char tcp;
> + int8_t ip;
> + int8_t tcp;
> char cptse; // current packet tse bit
> } tx;
>
> @@ -824,8 +824,8 @@
> qemu_put_be16s(f, &s->tx.size);
> qemu_put_be16s(f, &s->tx.tso_frames);
> qemu_put_8s(f, &s->tx.sum_needed);
> - qemu_put_8s(f, &s->tx.ip);
> - qemu_put_8s(f, &s->tx.tcp);
> + qemu_put_s8s(f, &s->tx.ip);
> + qemu_put_s8s(f, &s->tx.tcp);
> qemu_put_buffer(f, s->tx.header, sizeof s->tx.header);
> qemu_put_buffer(f, s->tx.data, sizeof s->tx.data);
> for (i = 0; i < 64; i++)
> @@ -849,7 +849,7 @@
> if ((ret = pci_device_load(&s->dev, f)) < 0)
> return ret;
> if (version_id == 1)
> - qemu_get_be32s(f, &i); /* once some unused instance id */
> + qemu_get_sbe32s(f, &i); /* once some unused instance id */
> qemu_get_be32s(f, &s->mmio_base);
> qemu_get_be32s(f, &s->rxbuf_size);
> qemu_get_be32s(f, &s->rxbuf_min_shift);
> @@ -870,8 +870,8 @@
> qemu_get_be16s(f, &s->tx.size);
> qemu_get_be16s(f, &s->tx.tso_frames);
> qemu_get_8s(f, &s->tx.sum_needed);
> - qemu_get_8s(f, &s->tx.ip);
> - qemu_get_8s(f, &s->tx.tcp);
> + qemu_get_s8s(f, &s->tx.ip);
> + qemu_get_s8s(f, &s->tx.tcp);
> qemu_get_buffer(f, s->tx.header, sizeof s->tx.header);
> qemu_get_buffer(f, s->tx.data, sizeof s->tx.data);
> for (i = 0; i < 64; i++)
>
> Modified: trunk/hw/esp.c
> ===================================================================
> --- trunk/hw/esp.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/esp.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -578,7 +578,7 @@
>
> qemu_put_buffer(f, s->rregs, ESP_REGS);
> qemu_put_buffer(f, s->wregs, ESP_REGS);
> - qemu_put_be32s(f, (uint32_t *)&s->ti_size);
> + qemu_put_sbe32s(f, &s->ti_size);
> qemu_put_be32s(f, &s->ti_rptr);
> qemu_put_be32s(f, &s->ti_wptr);
> qemu_put_buffer(f, s->ti_buf, TI_BUFSZ);
> @@ -600,7 +600,7 @@
>
> qemu_get_buffer(f, s->rregs, ESP_REGS);
> qemu_get_buffer(f, s->wregs, ESP_REGS);
> - qemu_get_be32s(f, (uint32_t *)&s->ti_size);
> + qemu_get_sbe32s(f, &s->ti_size);
> qemu_get_be32s(f, &s->ti_rptr);
> qemu_get_be32s(f, &s->ti_wptr);
> qemu_get_buffer(f, s->ti_buf, TI_BUFSZ);
>
> Modified: trunk/hw/hw.h
> ===================================================================
> --- trunk/hw/hw.h 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/hw.h 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -10,15 +10,31 @@
> QEMUFile *qemu_fopen(const char *filename, const char *mode);
> void qemu_fflush(QEMUFile *f);
> void qemu_fclose(QEMUFile *f);
> -void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
> -void qemu_put_byte(QEMUFile *f, int v);
> -void qemu_put_be16(QEMUFile *f, unsigned int v);
> -void qemu_put_be32(QEMUFile *f, unsigned int v);
> +void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size);
> +void qemu_put_byte(QEMUFile *f, int8_t v);
> +
> +static inline void qemu_put_ubyte(QEMUFile *f, uint8_t v)
> +{
> + qemu_put_byte(f, (int8_t)v);
> +}
> +
> +#define qemu_put_sbyte qemu_put_byte
> +
> +void qemu_put_be16(QEMUFile *f, uint16_t v);
> +void qemu_put_be32(QEMUFile *f, uint32_t v);
> void qemu_put_be64(QEMUFile *f, uint64_t v);
> -int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
> -int qemu_get_byte(QEMUFile *f);
> -unsigned int qemu_get_be16(QEMUFile *f);
> -unsigned int qemu_get_be32(QEMUFile *f);
> +size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size);
> +int8_t qemu_get_byte(QEMUFile *f);
> +
> +static inline uint8_t qemu_get_ubyte(QEMUFile *f)
> +{
> + return (uint8_t)qemu_get_byte(f);
> +}
> +
> +#define qemu_get_sbyte qemu_get_byte
> +
> +uint16_t qemu_get_be16(QEMUFile *f);
> +uint32_t qemu_get_be32(QEMUFile *f);
> uint64_t qemu_get_be64(QEMUFile *f);
>
> static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
> @@ -61,17 +77,106 @@
> *pv = qemu_get_byte(f);
> }
>
> +// Signed versions for type safety
> +static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, size_t size)
> +{
> + qemu_put_buffer(f, (const uint8_t *)buf, size);
> +}
> +
> +static inline void qemu_put_sbe16(QEMUFile *f, int16_t v)
> +{
> + qemu_put_be16(f, (uint16_t)v);
> +}
> +
> +static inline void qemu_put_sbe32(QEMUFile *f, int32_t v)
> +{
> + qemu_put_be32(f, (uint32_t)v);
> +}
> +
> +static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
> +{
> + qemu_put_be64(f, (uint64_t)v);
> +}
> +
> +static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, size_t size)
> +{
> + return qemu_get_buffer(f, (uint8_t *)buf, size);
> +}
> +
> +static inline int16_t qemu_get_sbe16(QEMUFile *f)
> +{
> + return (int16_t)qemu_get_be16(f);
> +}
> +
> +static inline int32_t qemu_get_sbe32(QEMUFile *f)
> +{
> + return (int32_t)qemu_get_be32(f);
> +}
> +
> +static inline int64_t qemu_get_sbe64(QEMUFile *f)
> +{
> + return (int64_t)qemu_get_be64(f);
> +}
> +
> +static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
> +{
> + qemu_put_8s(f, (const uint8_t *)pv);
> +}
> +
> +static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
> +{
> + qemu_put_be16s(f, (const uint16_t *)pv);
> +}
> +
> +static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
> +{
> + qemu_put_be32s(f, (const uint32_t *)pv);
> +}
> +
> +static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
> +{
> + qemu_put_be64s(f, (const uint64_t *)pv);
> +}
> +
> +static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
> +{
> + qemu_get_8s(f, (uint8_t *)pv);
> +}
> +
> +static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
> +{
> + qemu_get_be16s(f, (uint16_t *)pv);
> +}
> +
> +static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
> +{
> + qemu_get_be32s(f, (uint32_t *)pv);
> +}
> +
> +static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
> +{
> + qemu_get_be64s(f, (uint64_t *)pv);
> +}
> +
> #ifdef NEED_CPU_H
> #if TARGET_LONG_BITS == 64
> #define qemu_put_betl qemu_put_be64
> #define qemu_get_betl qemu_get_be64
> #define qemu_put_betls qemu_put_be64s
> #define qemu_get_betls qemu_get_be64s
> +#define qemu_put_sbetl qemu_put_sbe64
> +#define qemu_get_sbetl qemu_get_sbe64
> +#define qemu_put_sbetls qemu_put_sbe64s
> +#define qemu_get_sbetls qemu_get_sbe64s
> #else
> #define qemu_put_betl qemu_put_be32
> #define qemu_get_betl qemu_get_be32
> #define qemu_put_betls qemu_put_be32s
> #define qemu_get_betls qemu_get_be32s
> +#define qemu_put_sbetl qemu_put_sbe32
> +#define qemu_get_sbetl qemu_get_sbe32
> +#define qemu_put_sbetls qemu_put_sbe32s
> +#define qemu_get_sbetls qemu_get_sbe32s
> #endif
> #endif
>
>
> Modified: trunk/hw/pcnet.c
> ===================================================================
> --- trunk/hw/pcnet.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/pcnet.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -1877,9 +1877,9 @@
> if (s->pci_dev)
> pci_device_save(s->pci_dev, f);
>
> - qemu_put_be32(f, s->rap);
> - qemu_put_be32(f, s->isr);
> - qemu_put_be32(f, s->lnkst);
> + qemu_put_sbe32(f, s->rap);
> + qemu_put_sbe32(f, s->isr);
> + qemu_put_sbe32(f, s->lnkst);
> qemu_put_be32s(f, &s->rdra);
> qemu_put_be32s(f, &s->tdra);
> qemu_put_buffer(f, s->prom, 16);
> @@ -1888,10 +1888,10 @@
> for (i = 0; i < 32; i++)
> qemu_put_be16s(f, &s->bcr[i]);
> qemu_put_be64s(f, &s->timer);
> - qemu_put_be32(f, s->xmit_pos);
> - qemu_put_be32(f, s->recv_pos);
> + qemu_put_sbe32(f, s->xmit_pos);
> + qemu_put_sbe32(f, s->recv_pos);
> qemu_put_buffer(f, s->buffer, 4096);
> - qemu_put_be32(f, s->tx_busy);
> + qemu_put_sbe32(f, s->tx_busy);
> qemu_put_timer(f, s->poll_timer);
> }
>
> @@ -1909,9 +1909,9 @@
> return ret;
> }
>
> - qemu_get_be32s(f, (uint32_t*)&s->rap);
> - qemu_get_be32s(f, (uint32_t*)&s->isr);
> - qemu_get_be32s(f, (uint32_t*)&s->lnkst);
> + qemu_get_sbe32s(f, &s->rap);
> + qemu_get_sbe32s(f, &s->isr);
> + qemu_get_sbe32s(f, &s->lnkst);
> qemu_get_be32s(f, &s->rdra);
> qemu_get_be32s(f, &s->tdra);
> qemu_get_buffer(f, s->prom, 16);
> @@ -1920,10 +1920,10 @@
> for (i = 0; i < 32; i++)
> qemu_get_be16s(f, &s->bcr[i]);
> qemu_get_be64s(f, &s->timer);
> - qemu_get_be32s(f, (uint32_t*)&s->xmit_pos);
> - qemu_get_be32s(f, (uint32_t*)&s->recv_pos);
> + qemu_get_sbe32s(f, &s->xmit_pos);
> + qemu_get_sbe32s(f, &s->recv_pos);
> qemu_get_buffer(f, s->buffer, 4096);
> - qemu_get_be32s(f, (uint32_t*)&s->tx_busy);
> + qemu_get_sbe32s(f, &s->tx_busy);
> qemu_get_timer(f, s->poll_timer);
>
> return 0;
>
> Modified: trunk/hw/ptimer.c
> ===================================================================
> --- trunk/hw/ptimer.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/ptimer.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -165,9 +165,9 @@
> qemu_put_be64s(f, &s->limit);
> qemu_put_be64s(f, &s->delta);
> qemu_put_be32s(f, &s->period_frac);
> - qemu_put_be64s(f, &s->period);
> - qemu_put_be64s(f, &s->last_event);
> - qemu_put_be64s(f, &s->next_event);
> + qemu_put_sbe64s(f, &s->period);
> + qemu_put_sbe64s(f, &s->last_event);
> + qemu_put_sbe64s(f, &s->next_event);
> qemu_put_timer(f, s->timer);
> }
>
> @@ -177,9 +177,9 @@
> qemu_get_be64s(f, &s->limit);
> qemu_get_be64s(f, &s->delta);
> qemu_get_be32s(f, &s->period_frac);
> - qemu_get_be64s(f, &s->period);
> - qemu_get_be64s(f, &s->last_event);
> - qemu_get_be64s(f, &s->next_event);
> + qemu_get_sbe64s(f, &s->period);
> + qemu_get_sbe64s(f, &s->last_event);
> + qemu_get_sbe64s(f, &s->next_event);
> qemu_get_timer(f, s->timer);
> }
>
>
> Modified: trunk/hw/pxa2xx.c
> ===================================================================
> --- trunk/hw/pxa2xx.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/pxa2xx.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -1233,9 +1233,9 @@
> qemu_put_be32s(f, &s->last_rycr);
> qemu_put_be32s(f, &s->last_swcr);
> qemu_put_be32s(f, &s->last_rtcpicr);
> - qemu_put_be64s(f, (uint64_t *) &s->last_hz);
> - qemu_put_be64s(f, (uint64_t *) &s->last_sw);
> - qemu_put_be64s(f, (uint64_t *) &s->last_pi);
> + qemu_put_sbe64s(f, &s->last_hz);
> + qemu_put_sbe64s(f, &s->last_sw);
> + qemu_put_sbe64s(f, &s->last_pi);
> }
>
> static int pxa2xx_rtc_load(QEMUFile *f, void *opaque, int version_id)
> @@ -1257,9 +1257,9 @@
> qemu_get_be32s(f, &s->last_rycr);
> qemu_get_be32s(f, &s->last_swcr);
> qemu_get_be32s(f, &s->last_rtcpicr);
> - qemu_get_be64s(f, (uint64_t *) &s->last_hz);
> - qemu_get_be64s(f, (uint64_t *) &s->last_sw);
> - qemu_get_be64s(f, (uint64_t *) &s->last_pi);
> + qemu_get_sbe64s(f, &s->last_hz);
> + qemu_get_sbe64s(f, &s->last_sw);
> + qemu_get_sbe64s(f, &s->last_pi);
>
> pxa2xx_rtc_alarm_update(s, s->rtsr);
>
>
> Modified: trunk/hw/pxa2xx_timer.c
> ===================================================================
> --- trunk/hw/pxa2xx_timer.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/pxa2xx_timer.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -384,8 +384,8 @@
> for (i = 0; i < 8; i ++) {
> qemu_put_be32s(f, &s->tm4[i].tm.value);
> qemu_put_be32(f, s->tm4[i].tm.level);
> - qemu_put_be32s(f, (uint32_t *) &s->tm4[i].oldclock);
> - qemu_put_be32s(f, (uint32_t *) &s->tm4[i].clock);
> + qemu_put_sbe32s(f, &s->tm4[i].oldclock);
> + qemu_put_sbe32s(f, &s->tm4[i].clock);
> qemu_put_be64s(f, &s->tm4[i].lastload);
> qemu_put_be32s(f, &s->tm4[i].freq);
> qemu_put_be32s(f, &s->tm4[i].control);
> @@ -418,8 +418,8 @@
> for (i = 0; i < 8; i ++) {
> qemu_get_be32s(f, &s->tm4[i].tm.value);
> s->tm4[i].tm.level = qemu_get_be32(f);
> - qemu_get_be32s(f, (uint32_t *) &s->tm4[i].oldclock);
> - qemu_get_be32s(f, (uint32_t *) &s->tm4[i].clock);
> + qemu_get_sbe32s(f, &s->tm4[i].oldclock);
> + qemu_get_sbe32s(f, &s->tm4[i].clock);
> qemu_get_be64s(f, &s->tm4[i].lastload);
> qemu_get_be32s(f, &s->tm4[i].freq);
> qemu_get_be32s(f, &s->tm4[i].control);
>
> Modified: trunk/hw/tcx.c
> ===================================================================
> --- trunk/hw/tcx.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/tcx.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -372,9 +372,9 @@
> {
> TCXState *s = opaque;
>
> - qemu_put_be16s(f, (uint16_t *)&s->height);
> - qemu_put_be16s(f, (uint16_t *)&s->width);
> - qemu_put_be16s(f, (uint16_t *)&s->depth);
> + qemu_put_be16s(f, &s->height);
> + qemu_put_be16s(f, &s->width);
> + qemu_put_be16s(f, &s->depth);
> qemu_put_buffer(f, s->r, 256);
> qemu_put_buffer(f, s->g, 256);
> qemu_put_buffer(f, s->b, 256);
> @@ -391,13 +391,13 @@
> return -EINVAL;
>
> if (version_id == 3) {
> - qemu_get_be32s(f, (uint32_t *)&dummy);
> - qemu_get_be32s(f, (uint32_t *)&dummy);
> - qemu_get_be32s(f, (uint32_t *)&dummy);
> + qemu_get_be32s(f, &dummy);
> + qemu_get_be32s(f, &dummy);
> + qemu_get_be32s(f, &dummy);
> }
> - qemu_get_be16s(f, (uint16_t *)&s->height);
> - qemu_get_be16s(f, (uint16_t *)&s->width);
> - qemu_get_be16s(f, (uint16_t *)&s->depth);
> + qemu_get_be16s(f, &s->height);
> + qemu_get_be16s(f, &s->width);
> + qemu_get_be16s(f, &s->depth);
> qemu_get_buffer(f, s->r, 256);
> qemu_get_buffer(f, s->g, 256);
> qemu_get_buffer(f, s->b, 256);
>
> Modified: trunk/hw/tmp105.c
> ===================================================================
> --- trunk/hw/tmp105.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/tmp105.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -185,9 +185,9 @@
>
> qemu_put_8s(f, &s->pointer);
> qemu_put_8s(f, &s->config);
> - qemu_put_be16s(f, (uint16_t *) &s->temperature);
> - qemu_put_be16s(f, (uint16_t *) &s->limit[0]);
> - qemu_put_be16s(f, (uint16_t *) &s->limit[1]);
> + qemu_put_sbe16s(f, &s->temperature);
> + qemu_put_sbe16s(f, &s->limit[0]);
> + qemu_put_sbe16s(f, &s->limit[1]);
> qemu_put_byte(f, s->alarm);
> s->faults = tmp105_faultq[(s->config >> 3) & 3]; /* F */
>
> @@ -204,9 +204,9 @@
>
> qemu_get_8s(f, &s->pointer);
> qemu_get_8s(f, &s->config);
> - qemu_get_be16s(f, (uint16_t *) &s->temperature);
> - qemu_get_be16s(f, (uint16_t *) &s->limit[0]);
> - qemu_get_be16s(f, (uint16_t *) &s->limit[1]);
> + qemu_get_sbe16s(f, &s->temperature);
> + qemu_get_sbe16s(f, &s->limit[0]);
> + qemu_get_sbe16s(f, &s->limit[1]);
> s->alarm = qemu_get_byte(f);
>
> tmp105_interrupt_update(s);
>
> Modified: trunk/hw/tsc210x.c
> ===================================================================
> --- trunk/hw/tsc210x.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/hw/tsc210x.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -1046,8 +1046,8 @@
> qemu_put_be16s(f, &s->pll[0]);
> qemu_put_be16s(f, &s->pll[1]);
> qemu_put_be16s(f, &s->volume);
> - qemu_put_be64(f, (uint64_t) (s->volume_change - now));
> - qemu_put_be64(f, (uint64_t) (s->powerdown - now));
> + qemu_put_sbe64(f, (s->volume_change - now));
> + qemu_put_sbe64(f, (s->powerdown - now));
> qemu_put_byte(f, s->softstep);
> qemu_put_be16s(f, &s->dac_power);
>
> @@ -1092,8 +1092,8 @@
> qemu_get_be16s(f, &s->pll[0]);
> qemu_get_be16s(f, &s->pll[1]);
> qemu_get_be16s(f, &s->volume);
> - s->volume_change = (int64_t) qemu_get_be64(f) + now;
> - s->powerdown = (int64_t) qemu_get_be64(f) + now;
> + s->volume_change = qemu_get_sbe64(f) + now;
> + s->powerdown = qemu_get_sbe64(f) + now;
> s->softstep = qemu_get_byte(f);
> qemu_get_be16s(f, &s->dac_power);
>
>
> Modified: trunk/target-i386/machine.c
> ===================================================================
> --- trunk/target-i386/machine.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/target-i386/machine.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -102,7 +102,7 @@
>
> /* MMU */
> a20_mask = (int32_t) env->a20_mask;
> - qemu_put_be32s(f, &a20_mask);
> + qemu_put_sbe32s(f, &a20_mask);
>
> /* XMM */
> qemu_put_be32s(f, &env->mxcsr);
> @@ -256,7 +256,7 @@
> qemu_get_betls(f, &env->dr[i]);
>
> /* MMU */
> - qemu_get_be32s(f, &a20_mask);
> + qemu_get_sbe32s(f, &a20_mask);
> env->a20_mask = a20_mask;
>
> qemu_get_be32s(f, &env->mxcsr);
>
> Modified: trunk/vl.c
> ===================================================================
> --- trunk/vl.c 2008-09-20 03:18:07 UTC (rev 5273)
> +++ trunk/vl.c 2008-09-20 08:04:11 UTC (rev 5274)
> @@ -6247,9 +6247,9 @@
> qemu_free(f);
> }
>
> -void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
> +void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size)
> {
> - int l;
> + size_t l;
> while (size > 0) {
> l = IO_BUF_SIZE - f->buf_index;
> if (l > size)
> @@ -6263,16 +6263,16 @@
> }
> }
>
> -void qemu_put_byte(QEMUFile *f, int v)
> +void qemu_put_byte(QEMUFile *f, int8_t v)
> {
> f->buf[f->buf_index++] = v;
> if (f->buf_index >= IO_BUF_SIZE)
> qemu_fflush(f);
> }
>
> -int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
> +size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size1)
> {
> - int size, l;
> + size_t size, l;
>
> size = size1;
> while (size > 0) {
> @@ -6293,7 +6293,7 @@
> return size1 - size;
> }
>
> -int qemu_get_byte(QEMUFile *f)
> +int8_t qemu_get_byte(QEMUFile *f)
> {
> if (f->buf_index >= f->buf_size) {
> qemu_fill_buffer(f);
> @@ -6329,13 +6329,13 @@
> return pos;
> }
>
> -void qemu_put_be16(QEMUFile *f, unsigned int v)
> +void qemu_put_be16(QEMUFile *f, uint16_t v)
> {
> qemu_put_byte(f, v >> 8);
> qemu_put_byte(f, v);
> }
>
> -void qemu_put_be32(QEMUFile *f, unsigned int v)
> +void qemu_put_be32(QEMUFile *f, uint32_t v)
> {
> qemu_put_byte(f, v >> 24);
> qemu_put_byte(f, v >> 16);
> @@ -6349,17 +6349,17 @@
> qemu_put_be32(f, v);
> }
>
> -unsigned int qemu_get_be16(QEMUFile *f)
> +uint16_t qemu_get_be16(QEMUFile *f)
> {
> - unsigned int v;
> + uint16_t v;
> v = qemu_get_byte(f) << 8;
> v |= qemu_get_byte(f);
> return v;
> }
>
> -unsigned int qemu_get_be32(QEMUFile *f)
> +uint32_t qemu_get_be32(QEMUFile *f)
> {
> - unsigned int v;
> + uint32_t v;
> v = qemu_get_byte(f) << 24;
> v |= qemu_get_byte(f) << 16;
> v |= qemu_get_byte(f) << 8;
>
>
>
>
>
next prev parent reply other threads:[~2008-09-25 18:24 UTC|newest]
Thread overview: 7+ messages / expand[flat|nested] mbox.gz Atom feed top
2008-09-20 8:04 [Qemu-devel] [5274] Add signed versions of save/load functions Blue Swirl
2008-09-25 18:23 ` Anthony Liguori [this message]
2008-09-25 18:47 ` Blue Swirl
2008-09-25 19:59 ` Anthony Liguori
2008-09-25 20:17 ` Blue Swirl
2008-09-25 20:20 ` Anthony Liguori
2008-09-25 21:14 ` Blue Swirl
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=48DBD707.4040806@codemonkey.ws \
--to=anthony@codemonkey.ws \
--cc=blauwirbel@gmail.com \
--cc=qemu-devel@nongnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).