static void pxa2xx_lcdc_save(QEMUFile *f, void *opaque) { PXA2xxLCDState *s = (PXA2xxLCDState *) opaque; int i; qemu_put_be32(f, s->irqlevel); qemu_put_be32(f, s->transp); for (i = 0; i < 6; i ++) qemu_put_be32s(f, &s->control[i]); for (i = 0; i < 2; i ++) qemu_put_be32s(f, &s->status[i]); for (i = 0; i < 2; i ++) qemu_put_be32s(f, &s->ovl1c[i]); for (i = 0; i < 2; i ++) qemu_put_be32s(f, &s->ovl2c[i]); qemu_put_be32s(f, &s->ccr); qemu_put_be32s(f, &s->cmdcr); qemu_put_be32s(f, &s->trgbr); qemu_put_be32s(f, &s->tcr); qemu_put_be32s(f, &s->liidr); qemu_put_8s(f, &s->bscntr); for (i = 0; i < 7; i ++) { qemu_put_betl(f, s->dma_ch[i].branch); qemu_put_byte(f, s->dma_ch[i].up); qemu_put_buffer(f, s->dma_ch[i].pbuffer, sizeof(s->dma_ch[i].pbuffer)); qemu_put_betl(f, s->dma_ch[i].descriptor); qemu_put_betl(f, s->dma_ch[i].source); qemu_put_be32s(f, &s->dma_ch[i].id); qemu_put_be32s(f, &s->dma_ch[i].command); } }
static void virtio_audio_save(QEMUFile *f, void *opaque) { VirtIOAudio *s = opaque; VirtIOAudioStream *stream; int i; int mode; virtio_save(&s->vdev, f); for (i = 0; i < NUM_STREAMS; i++) { stream = &s->stream[i]; if (stream->in_voice) { mode = 2; if (AUD_is_active_in(stream->in_voice)) mode |= 1; } else if (stream->out_voice) { mode = 4; if (AUD_is_active_out(stream->out_voice)) mode |= 1; } else { mode = 0; } qemu_put_byte(f, mode); qemu_put_byte(f, stream->fmt.endianness); qemu_put_be16(f, stream->fmt.nchannels); qemu_put_be32(f, stream->fmt.fmt); qemu_put_be32(f, stream->fmt.freq); } }
static int boot_property_save_property( QEMUFile *f, BootProperty *p ) { char *split = strchr(p->property, '='); if (split == NULL) { D("%s: save failed: illegal key/value pair \"%s\" (missing '=')\n", __FUNCTION__, p->property); qemu_file_set_error(f); return -1; } *split = '\0'; uint32_t key_buf_len = (split - p->property) + 1; qemu_put_be32(f, key_buf_len); qemu_put_buffer(f, (uint8_t*) p->property, key_buf_len); uint32_t value_buf_len = p->length - key_buf_len + 1; qemu_put_be32(f, value_buf_len); qemu_put_buffer(f, (uint8_t*) split + 1, value_buf_len); *split = '='; return 0; }
static void rtc_save_td(QEMUFile *f, void *opaque) { RTCState *s = opaque; qemu_put_be32(f, s->irq_coalesced); qemu_put_be32(f, s->period); }
static void cpu_put_seg(QEMUFile *f, SegmentCache *dt) { qemu_put_be32(f, dt->selector); qemu_put_betl(f, dt->base); qemu_put_be32(f, dt->limit); qemu_put_be32(f, dt->flags); }
static void virtio_balloon_save_device(VirtIODevice *vdev, QEMUFile *f) { VirtIOBalloon *s = VIRTIO_BALLOON(vdev); qemu_put_be32(f, s->num_pages); qemu_put_be32(f, s->actual); }
/* Saves a single BootProperty to file. */ static int boot_property_save_property( QEMUFile *f, BootProperty *p ) { /* split in key and value, so we can re-use boot_property_add (and its * sanity checks) when loading */ char *split = strchr(p->property, '='); if (split == NULL) { D("%s: save failed: illegal key/value pair \"%s\" (missing '=')\n", __FUNCTION__, p->property); qemu_file_set_error(f, -EINVAL); return -1; } *split = '\0'; /* p->property is now "<key>\0<value>\0" */ uint32_t key_buf_len = (split - p->property) + 1; // +1: '\0' terminator qemu_put_be32(f, key_buf_len); qemu_put_buffer(f, (uint8_t*) p->property, key_buf_len); uint32_t value_buf_len = p->length - key_buf_len + 1; // +1: '\0' terminator qemu_put_be32(f, value_buf_len); qemu_put_buffer(f, (uint8_t*) split + 1, value_buf_len); *split = '='; /* restore property to "<key>=<value>\0" */ return 0; }
void virtio_save(VirtIODevice *vdev, QEMUFile *f) { int i; if (vdev->binding->save_config) vdev->binding->save_config(vdev->binding_opaque, f); qemu_put_8s(f, &vdev->status); qemu_put_8s(f, &vdev->isr); qemu_put_be16s(f, &vdev->queue_sel); qemu_put_be32s(f, &vdev->guest_features); qemu_put_be32(f, vdev->config_len); qemu_put_buffer(f, vdev->config, vdev->config_len); for (i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) { if (vdev->vq[i].vring.num == 0) break; } qemu_put_be32(f, i); for (i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) { if (vdev->vq[i].vring.num == 0) break; qemu_put_be32(f, vdev->vq[i].vring.num); qemu_put_be64(f, vdev->vq[i].pa); qemu_put_be16s(f, &vdev->vq[i].last_avail_idx); if (vdev->binding->save_queue) vdev->binding->save_queue(vdev->binding_opaque, i, f); } }
static void goldfish_pipe_save( QEMUFile* file, void* opaque ) { PipeDevice* dev = opaque; Pipe* pipe; qemu_put_be32(file, dev->address); qemu_put_be32(file, dev->size); qemu_put_be32(file, dev->status); qemu_put_be32(file, dev->channel); qemu_put_be32(file, dev->wakes); qemu_put_be64(file, dev->params_addr); int count = 0; for ( pipe = dev->pipes; pipe; pipe = pipe->next ) count++; qemu_put_sbe32(file, count); for ( pipe = dev->pipes; pipe; pipe = pipe->next ) { pipe_save(pipe, file); } }
static void pxa2xx_timer_save(QEMUFile *f, void *opaque) { pxa2xx_timer_info *s = (pxa2xx_timer_info *) opaque; int i; qemu_put_be32s(f, &s->clock); qemu_put_be32s(f, &s->oldclock); qemu_put_be64s(f, &s->lastload); for (i = 0; i < 4; i ++) { qemu_put_be32s(f, &s->timer[i].value); qemu_put_be32(f, s->timer[i].level); } if (s->tm4) 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, &s->tm4[i].oldclock); qemu_put_be32s(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); } qemu_put_be32s(f, &s->events); qemu_put_be32s(f, &s->irq_enabled); qemu_put_be32s(f, &s->reset3); qemu_put_be32s(f, &s->snapshot); }
static void virtio_mmio_save_config(DeviceState *opaque, QEMUFile *f) { VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); qemu_put_be32(f, proxy->host_features_sel); qemu_put_be32(f, proxy->guest_features_sel); qemu_put_be32(f, proxy->guest_page_shift); }
static void arm_timer_save(QEMUFile *f, void *opaque) { arm_timer_state *s = (arm_timer_state *)opaque; qemu_put_be32(f, s->control); qemu_put_be32(f, s->limit); qemu_put_be32(f, s->int_level); qemu_put_ptimer(f, s->timer); }
static void goldfish_audio_buff_put( struct goldfish_audio_buff* b, QEMUFile* f ) { qemu_put_be32(f, b->address ); qemu_put_be32(f, b->length ); qemu_put_be32(f, b->offset ); qemu_put_buffer(f, b->data, b->length ); }
static void omap3_l4ta_save_state(QEMUFile *f, void *opaque) { struct omap_target_agent_s *s = (struct omap_target_agent_s *)opaque; qemu_put_be32(f, s->control); qemu_put_be32(f, s->control_h); qemu_put_be32(f, s->status); }
static void ps2_common_save (QEMUFile *f, PS2State *s) { qemu_put_be32 (f, s->write_cmd); qemu_put_be32 (f, s->queue.rptr); qemu_put_be32 (f, s->queue.wptr); qemu_put_be32 (f, s->queue.count); qemu_put_buffer (f, s->queue.data, sizeof (s->queue.data)); }
static void ps2_kbd_save(QEMUFile* f, void* opaque) { PS2KbdState *s = (PS2KbdState*)opaque; ps2_common_save (f, &s->common); qemu_put_be32(f, s->scan_enabled); qemu_put_be32(f, s->translate); }
/* Saves sensor-specific client data to snapshot */ static void _hwSensorClient_save( QEMUFile* f, QemudClient* client, void* opaque ) { HwSensorClient* sc = opaque; qemu_put_be32(f, sc->delay_ms); qemu_put_be32(f, sc->enabledMask); qemu_put_timer(f, sc->timer); }
static void virtio_balloon_save(QEMUFile *f, void *opaque) { VirtIOBalloon *s = opaque; virtio_save(&s->vdev, f); qemu_put_be32(f, s->num_pages); qemu_put_be32(f, s->actual); }
static void goldfish_tty_save(QEMUFile* f, void* opaque) { struct tty_state* s = opaque; qemu_put_be32( f, s->ptr ); qemu_put_be32( f, s->ptr_len ); qemu_put_byte( f, s->ready ); qemu_put_byte( f, s->data_count ); qemu_put_buffer( f, s->data, s->data_count ); }
static void virtio_balloon_save(QEMUFile *f, void *opaque) { VirtIOBalloon *s = VIRTIO_BALLOON(opaque); VirtIODevice *vdev = VIRTIO_DEVICE(s); virtio_save(vdev, f); qemu_put_be32(f, s->num_pages); qemu_put_be32(f, s->actual); }
static void goldfish_tty_save(QEMUFile* f, void* opaque) { struct tty_state* s = opaque; qemu_put_be32( f, s->ptr ); qemu_put_be32( f, s->ptr_len ); qemu_put_byte( f, (s_tty.int_mask & DEV_MASK(s->dev.id)) ? 1 : 0 ); qemu_put_byte( f, s->data_count ); qemu_put_buffer( f, s->data, s->data_count ); }
static void syborg_int_save(QEMUFile *f, void *opaque) { SyborgIntState *s = (SyborgIntState *)opaque; int i; qemu_put_be32(f, s->num_irqs); qemu_put_be32(f, s->pending_count); for (i = 0; i < s->num_irqs; i++) { qemu_put_be32(f, s->flags[i].enabled | ((unsigned)s->flags[i].level << 1)); } }
static void slirp_sbuf_save(QEMUFile *f, struct sbuf *sbuf) { uint32_t off; qemu_put_be32(f, sbuf->sb_cc); qemu_put_be32(f, sbuf->sb_datalen); off = (uint32_t)(sbuf->sb_wptr - sbuf->sb_data); qemu_put_sbe32(f, off); off = (uint32_t)(sbuf->sb_rptr - sbuf->sb_data); qemu_put_sbe32(f, off); qemu_put_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen); }
static void max111x_save(QEMUFile *f, void *opaque) { struct max111x_s *s = (struct max111x_s *) opaque; int i; qemu_put_8s(f, &s->tb1); qemu_put_8s(f, &s->rb2); qemu_put_8s(f, &s->rb3); qemu_put_be32(f, s->inputs); qemu_put_be32(f, s->com); for (i = 0; i < s->inputs; i ++) qemu_put_byte(f, s->input[i]); }
static void slirp_socket_save(QEMUFile *f, struct socket *so) { qemu_put_be32(f, so->so_urgc); qemu_put_be32(f, so->so_faddr_ip); qemu_put_be32(f, so->so_laddr_ip); qemu_put_be16(f, so->so_faddr_port); qemu_put_be16(f, so->so_laddr_port); qemu_put_byte(f, so->so_iptos); qemu_put_byte(f, so->so_emu); qemu_put_byte(f, so->so_type); qemu_put_be32(f, so->so_state); slirp_sbuf_save(f, &so->so_rcv); slirp_sbuf_save(f, &so->so_snd); slirp_tcp_save(f, so->so_tcpcb); }
static void ivshmem_save(QEMUFile* f, void *opaque) { IVShmemState *proxy = opaque; IVSHMEM_DPRINTF("ivshmem_save\n"); pci_device_save(&proxy->dev, f); if (ivshmem_has_feature(proxy, IVSHMEM_MSI)) { msix_save(&proxy->dev, f); } else { qemu_put_be32(f, proxy->intrstatus); qemu_put_be32(f, proxy->intrmask); } }
static void put_fpscr(QEMUFile *f, void *opaque, size_t size) { ARMCPU *cpu = opaque; CPUARMState *env = &cpu->env; qemu_put_be32(f, vfp_get_fpscr(env)); }
static void put_cpsr(QEMUFile *f, void *opaque, size_t size) { ARMCPU *cpu = opaque; CPUARMState *env = &cpu->env; qemu_put_be32(f, cpsr_read(env)); }
void cpu_save(QEMUFile * f, void * opaque) { int i; CPUSRPState *env = (CPUSRPState *)opaque; for (i = 0; i < SRP_REGS; i++) { qemu_put_be32(f, env->regs[i]); } qemu_put_be32(f, env->irq); qemu_put_be32(f, env->psw); qemu_put_be32(f, env->sp); qemu_put_be32(f, env->pc); }
static int put_vscr(QEMUFile *f, void *opaque, size_t size, const VMStateField *field, QJSON *vmdesc) { PowerPCCPU *cpu = opaque; qemu_put_be32(f, helper_mfvscr(&cpu->env)); return 0; }