static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)
{
int i;
tp->t_state = qemu_get_sbe16(f);
for (i = 0; i < TCPT_NTIMERS; i++)
tp->t_timer[i] = qemu_get_sbe16(f);
tp->t_rxtshift = qemu_get_sbe16(f);
tp->t_rxtcur = qemu_get_sbe16(f);
tp->t_dupacks = qemu_get_sbe16(f);
tp->t_maxseg = qemu_get_be16(f);
tp->t_force = qemu_get_sbyte(f);
tp->t_flags = qemu_get_be16(f);
tp->snd_una = qemu_get_be32(f);
tp->snd_nxt = qemu_get_be32(f);
tp->snd_up = qemu_get_be32(f);
tp->snd_wl1 = qemu_get_be32(f);
tp->snd_wl2 = qemu_get_be32(f);
tp->iss = qemu_get_be32(f);
tp->snd_wnd = qemu_get_be32(f);
tp->rcv_wnd = qemu_get_be32(f);
tp->rcv_nxt = qemu_get_be32(f);
tp->rcv_up = qemu_get_be32(f);
tp->irs = qemu_get_be32(f);
tp->rcv_adv = qemu_get_be32(f);
tp->snd_max = qemu_get_be32(f);
tp->snd_cwnd = qemu_get_be32(f);
tp->snd_ssthresh = qemu_get_be32(f);
tp->t_idle = qemu_get_sbe16(f);
tp->t_rtt = qemu_get_sbe16(f);
tp->t_rtseq = qemu_get_be32(f);
tp->t_srtt = qemu_get_sbe16(f);
tp->t_rttvar = qemu_get_sbe16(f);
tp->t_rttmin = qemu_get_be16(f);
tp->max_sndwnd = qemu_get_be32(f);
tp->t_oobflags = qemu_get_byte(f);
tp->t_iobc = qemu_get_byte(f);
tp->t_softerror = qemu_get_sbe16(f);
tp->snd_scale = qemu_get_byte(f);
tp->rcv_scale = qemu_get_byte(f);
tp->request_r_scale = qemu_get_byte(f);
tp->requested_s_scale = qemu_get_byte(f);
tp->ts_recent = qemu_get_be32(f);
tp->ts_recent_age = qemu_get_be32(f);
tp->last_ack_sent = qemu_get_be32(f);
tcp_template(tp);
}
static int smc91c111_load(QEMUFile *f, void *opaque, int version_id)
{
smc91c111_state *s = opaque;
if (version_id != SMC91C111_SAVE_VERSION) {
return -1;
}
s->tcr = qemu_get_be16(f);
s->rcr = qemu_get_be16(f);
s->cr = qemu_get_be16(f);
s->ctr = qemu_get_be16(f);
s->gpr = qemu_get_be16(f);
s->ptr = qemu_get_be16(f);
s->ercv = qemu_get_be16(f);
s->bank = qemu_get_be32(f);
s->packet_num = qemu_get_be32(f);
s->tx_alloc = qemu_get_be32(f);
s->allocated = qemu_get_be32(f);
s->tx_fifo_len = qemu_get_be32(f);
qemu_get_buffer(f, (uint8_t*) s->tx_fifo, sizeof(s->tx_fifo));
s->rx_fifo_len = qemu_get_be32(f);
qemu_get_buffer(f, (uint8_t*) s->rx_fifo, sizeof(s->rx_fifo));
s->tx_fifo_done_len = qemu_get_be32(f);
qemu_get_buffer(f, (uint8_t*) s->tx_fifo_done, sizeof(s->tx_fifo_done));
/* Packet buffer memory. */
qemu_get_buffer(f, (uint8_t*) s->data, sizeof(s->data));
s->int_level = qemu_get_byte(f);
s->int_mask = qemu_get_byte(f);
return 0;
}
static int eeprom_load(QEMUFile *f, void *opaque, int version_id)
{
/* Load EEPROM data from saved data if version and EEPROM size
of data and current EEPROM are identical. */
eeprom_t *eeprom = (eeprom_t *)opaque;
int result = -EINVAL;
if (version_id == eeprom_version) {
unsigned address;
uint8_t size = eeprom->size;
qemu_get_buffer(f, (uint8_t *)eeprom, sizeof(*eeprom) - 2);
if (eeprom->size == size) {
eeprom->data = qemu_get_be16(f);
for (address = 0; address < eeprom->size; address++) {
eeprom->contents[address] = qemu_get_be16(f);
}
result = 0;
}
}
return result;
}
static int slirp_socket_load(QEMUFile *f, struct socket *so)
{
if (tcp_attach(so) < 0)
return -ENOMEM;
so->so_urgc = qemu_get_be32(f);
so->so_faddr_ip = qemu_get_be32(f);
so->so_laddr_ip = qemu_get_be32(f);
so->so_faddr_port = qemu_get_be16(f);
so->so_laddr_port = qemu_get_be16(f);
so->so_iptos = qemu_get_byte(f);
so->so_emu = qemu_get_byte(f);
so->so_type = qemu_get_byte(f);
so->so_state = qemu_get_be32(f);
if (slirp_sbuf_load(f, &so->so_rcv) < 0)
return -ENOMEM;
if (slirp_sbuf_load(f, &so->so_snd) < 0)
return -ENOMEM;
slirp_tcp_load(f, so->so_tcpcb);
return 0;
}
static int virtio_audio_load(QEMUFile *f, void *opaque, int version_id)
{
VirtIOAudio *s = opaque;
VirtIOAudioStream *stream;
int i;
int mode;
if (version_id != 1)
return -EINVAL;
/* FIXME: Do bad things happen if there is a transfer in progress? */
virtio_load(&s->vdev, f);
for (i = 0; i < NUM_STREAMS; i++) {
stream = &s->stream[i];
stream->has_buffer = 0;
stream->data_left = 0;
if (stream->in_voice) {
AUD_close_in(&s->card, stream->in_voice);
stream->in_voice = NULL;
}
if (stream->out_voice) {
AUD_close_out(&s->card, stream->out_voice);
stream->out_voice = NULL;
}
mode = qemu_get_byte(f);
stream->fmt.endianness = qemu_get_byte(f);
stream->fmt.nchannels = qemu_get_be16(f);
stream->fmt.fmt = qemu_get_be32(f);
stream->fmt.freq = qemu_get_be32(f);
if (mode & 2) {
stream->in_voice = AUD_open_in(&s->card, stream->in_voice,
"virtio-audio.in",
stream,
virtio_audio_callback,
&stream->fmt);
AUD_set_active_in(stream->in_voice, mode & 1);
} else if (mode & 4) {
stream->out_voice = AUD_open_out(&s->card, stream->out_voice,
"virtio-audio.out",
stream,
virtio_audio_callback,
&stream->fmt);
AUD_set_active_out(stream->out_voice, mode & 1);
}
}
return 0;
}
static int eeprom_load(QEMUFile *f, void *opaque, int version_id)
{
/* Load EEPROM data from saved data if version and EEPROM size
of data and current EEPROM are identical. */
eeprom_t *eeprom = (eeprom_t *)opaque;
int result = -EINVAL;
if (version_id >= OLD_EEPROM_VERSION) {
unsigned address;
int size = eeprom->size;
eeprom->tick = qemu_get_byte(f);
eeprom->address = qemu_get_byte(f);
eeprom->command = qemu_get_byte(f);
eeprom->writeable = qemu_get_byte(f);
eeprom->eecs = qemu_get_byte(f);
eeprom->eesk = qemu_get_byte(f);
eeprom->eedo = qemu_get_byte(f);
eeprom->addrbits = qemu_get_byte(f);
if (version_id == OLD_EEPROM_VERSION) {
eeprom->size = qemu_get_byte(f);
qemu_get_byte(f);
} else {
eeprom->size = qemu_get_be16(f);
}
if (eeprom->size == size) {
eeprom->data = qemu_get_be16(f);
for (address = 0; address < eeprom->size; address++) {
eeprom->contents[address] = qemu_get_be16(f);
}
result = 0;
}
}
return result;
}
int TEMU_decompress_buf(TEMU_CompressState_t *s, uint8_t *buf, int len)
{
int ret, clen;
s->zstream.avail_out = len;
s->zstream.next_out = buf;
while (s->zstream.avail_out > 0) {
if (s->zstream.avail_in == 0) {
if (qemu_get_be16((QEMUFile *)s->f) != TEMU_CBLOCK_MAGIC)
return -1;
clen = qemu_get_be16((QEMUFile *)s->f);
if (clen > IOBUF_SIZE)
return -1;
qemu_get_buffer((QEMUFile *)s->f, s->buf, clen);
s->zstream.avail_in = clen;
s->zstream.next_in = s->buf;
}
ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
if (ret != Z_OK && ret != Z_STREAM_END) {
return -1;
}
}
return 0;
}
static int get_uint32_as_uint16(QEMUFile *f, void *pv, size_t size)
{
uint32_t *v = pv;
*v = qemu_get_be16(f);
return 0;
}
