static void pxa2xx_mmci_save(QEMUFile *f, void *opaque) { PXA2xxMMCIState *s = (PXA2xxMMCIState *) opaque; int i; qemu_put_be32s(f, &s->status); qemu_put_be32s(f, &s->clkrt); qemu_put_be32s(f, &s->spi); qemu_put_be32s(f, &s->cmdat); qemu_put_be32s(f, &s->resp_tout); qemu_put_be32s(f, &s->read_tout); qemu_put_be32(f, s->blklen); qemu_put_be32(f, s->numblk); qemu_put_be32s(f, &s->intmask); qemu_put_be32s(f, &s->intreq); qemu_put_be32(f, s->cmd); qemu_put_be32s(f, &s->arg); qemu_put_be32(f, s->cmdreq); qemu_put_be32(f, s->active); qemu_put_be32(f, s->bytesleft); qemu_put_byte(f, s->tx_len); for (i = 0; i < s->tx_len; i ++) qemu_put_byte(f, s->tx_fifo[(s->tx_start + i) & 63]); qemu_put_byte(f, s->rx_len); for (i = 0; i < s->rx_len; i ++) qemu_put_byte(f, s->rx_fifo[(s->rx_start + i) & 31]); qemu_put_byte(f, s->resp_len); for (i = s->resp_len; i < 9; i ++) qemu_put_be16s(f, &s->resp_fifo[i]); }
static void smc91c111_save(QEMUFile *f, void *opaque) { smc91c111_state *s = opaque; qemu_put_be16(f, s->tcr); qemu_put_be16(f, s->rcr); qemu_put_be16(f, s->cr); qemu_put_be16(f, s->ctr); qemu_put_be16(f, s->gpr); qemu_put_be16(f, s->ptr); qemu_put_be16(f, s->ercv); qemu_put_be32(f, s->bank); qemu_put_be32(f, s->packet_num); qemu_put_be32(f, s->tx_alloc); qemu_put_be32(f, s->allocated); qemu_put_be32(f, s->tx_fifo_len); qemu_put_buffer(f, (uint8_t*) s->tx_fifo, sizeof(s->tx_fifo)); qemu_put_be32(f, s->rx_fifo_len); qemu_put_buffer(f, (uint8_t*) s->rx_fifo, sizeof(s->rx_fifo)); qemu_put_be32(f, s->tx_fifo_done_len); qemu_put_buffer(f, (uint8_t*) s->tx_fifo_done, sizeof(s->tx_fifo_done)); qemu_put_buffer(f, (uint8_t*) s->data, sizeof(s->data)); qemu_put_byte(f, s->int_level); qemu_put_byte(f, s->int_mask); }
static void rotary_save(QEMUFile *f, void *opaque) { RotaryCoderState *s = opaque; qemu_put_byte(f, s->state); qemu_put_byte(f, s->extension); }
static void goldfish_switch_save(QEMUFile* f, void* opaque) { struct switch_state* s = opaque; qemu_put_be32(f, s->state); qemu_put_byte(f, s->state_changed); qemu_put_byte(f, s->int_enable); }
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 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 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 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 int ram_save_block(QEMUFile *f) { static ram_addr_t current_addr = 0; ram_addr_t saved_addr = current_addr; ram_addr_t addr = 0; int found = 0; while (addr < last_ram_offset) { if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) { uint8_t *p; cpu_physical_memory_reset_dirty(current_addr, current_addr + TARGET_PAGE_SIZE, MIGRATION_DIRTY_FLAG); p = qemu_get_ram_ptr(current_addr); if (is_dup_page(p, *p)) { qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS); qemu_put_byte(f, *p); } else { qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE); qemu_put_buffer(f, p, TARGET_PAGE_SIZE); } found = 1; break; } addr += TARGET_PAGE_SIZE; current_addr = (saved_addr + addr) % last_ram_offset; } return found; }
static int put_bool(QEMUFile *f, void *pv, size_t size, VMStateField *field, QJSON *vmdesc) { bool *v = pv; qemu_put_byte(f, *v); return 0; }
static int save_xbzrle_page(QEMUFile *f, uint8_t **current_data, ram_addr_t current_addr, RAMBlock *block, ram_addr_t offset, int cont, bool last_stage) { int encoded_len = 0, bytes_sent = -1; uint8_t *prev_cached_page; if (!cache_is_cached(XBZRLE.cache, current_addr)) { acct_info.xbzrle_cache_miss++; if (!last_stage) { if (cache_insert(XBZRLE.cache, current_addr, *current_data) == -1) { return -1; } else { /* update *current_data when the page has been inserted into cache */ *current_data = get_cached_data(XBZRLE.cache, current_addr); } } return -1; } prev_cached_page = get_cached_data(XBZRLE.cache, current_addr); /* save current buffer into memory */ memcpy(XBZRLE.current_buf, *current_data, TARGET_PAGE_SIZE); /* XBZRLE encoding (if there is no overflow) */ encoded_len = xbzrle_encode_buffer(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE, XBZRLE.encoded_buf, TARGET_PAGE_SIZE); if (encoded_len == 0) { DPRINTF("Skipping unmodified page\n"); return 0; } else if (encoded_len == -1) { DPRINTF("Overflow\n"); acct_info.xbzrle_overflows++; /* update data in the cache */ if (!last_stage) { memcpy(prev_cached_page, *current_data, TARGET_PAGE_SIZE); *current_data = prev_cached_page; } return -1; } /* we need to update the data in the cache, in order to get the same data */ if (!last_stage) { memcpy(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE); } /* Send XBZRLE based compressed page */ bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE); qemu_put_byte(f, ENCODING_FLAG_XBZRLE); qemu_put_be16(f, encoded_len); qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len); bytes_sent += encoded_len + 1 + 2; acct_info.xbzrle_pages++; acct_info.xbzrle_bytes += bytes_sent; return bytes_sent; }
static void slirp_state_save(QEMUFile *f, void *opaque) { struct ex_list *ex_ptr; for (ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) if (ex_ptr->ex_pty == 3) { struct socket *so; so = slirp_find_ctl_socket(ex_ptr->ex_addr, ntohs(ex_ptr->ex_fport)); if (!so) continue; qemu_put_byte(f, 42); slirp_socket_save(f, so); } qemu_put_byte(f, 0); }
static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd, void *opaque, QJSON *vmdesc) { const VMStateDescription **sub = vmsd->subsections; bool subsection_found = false; int ret = 0; trace_vmstate_subsection_save_top(vmsd->name); while (sub && *sub) { if (vmstate_save_needed(*sub, opaque)) { const VMStateDescription *vmsdsub = *sub; uint8_t len; trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name); if (vmdesc) { /* Only create subsection array when we have any */ if (!subsection_found) { json_start_array(vmdesc, "subsections"); subsection_found = true; } json_start_object(vmdesc, NULL); } qemu_put_byte(f, QEMU_VM_SUBSECTION); len = strlen(vmsdsub->name); qemu_put_byte(f, len); qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len); qemu_put_be32(f, vmsdsub->version_id); ret = vmstate_save_state(f, vmsdsub, opaque, vmdesc); if (ret) { return ret; } if (vmdesc) { json_end_object(vmdesc); } } sub++; } if (vmdesc && subsection_found) { json_end_array(vmdesc); } return ret; }
void gtod_save(QEMUFile *f, void *opaque) { uint64_t tod_low; uint8_t tod_high; int r; r = s390_get_clock(&tod_high, &tod_low); if (r) { fprintf(stderr, "WARNING: Unable to get guest clock for migration. " "Error code %d. Guest clock will not be migrated " "which could cause the guest to hang.\n", r); qemu_put_byte(f, S390_TOD_CLOCK_VALUE_MISSING); return; } qemu_put_byte(f, S390_TOD_CLOCK_VALUE_PRESENT); qemu_put_byte(f, tod_high); qemu_put_be64(f, tod_low); }
static void save_vmstate(const VMStateDescription *desc, void *obj) { QEMUFile *f = open_test_file(true); /* Save file with vmstate */ vmstate_save_state(f, desc, obj); qemu_put_byte(f, QEMU_VM_EOF); g_assert(!qemu_file_get_error(f)); qemu_fclose(f); }
static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd, void *opaque) { const VMStateSubsection *sub = vmsd->subsections; while (sub && sub->needed) { if (sub->needed(opaque)) { const VMStateDescription *vmsd = sub->vmsd; uint8_t len; qemu_put_byte(f, QEMU_VM_SUBSECTION); len = strlen(vmsd->name); qemu_put_byte(f, len); qemu_put_buffer(f, (uint8_t *)vmsd->name, len); qemu_put_be32(f, vmsd->version_id); vmstate_save_state(f, vmsd, opaque); } sub++; } }
static void goldfish_timer_save(QEMUFile* f, void* opaque) { struct timer_state* s = opaque; qemu_put_be64(f, s->now); /* in case the kernel is in the middle of a timer read */ qemu_put_byte(f, s->armed); if (s->armed) { int64_t now = qemu_get_clock(vm_clock); int64_t alarm = muldiv64(s->alarm_low | (int64_t)s->alarm_high << 32, ticks_per_sec, 1000000000); qemu_put_be64(f, alarm-now); } }
static void nvram_writeb (void *opaque, target_phys_addr_t addr, uint32_t value) { ds1225y_t *NVRAM = opaque; int64_t pos; pos = addr - NVRAM->mem_base; if (ds1225y_set_to_mode(NVRAM, writemode, "wb")) { qemu_fseek(NVRAM->file, pos, SEEK_SET); qemu_put_byte(NVRAM->file, (int)value); } }
static void goldfish_timer_save(QEMUFile* f, void* opaque) { struct timer_state* s = opaque; qemu_put_be64(f, s->now_ns); /* in case the kernel is in the middle of a timer read */ qemu_put_byte(f, s->armed); if (s->armed) { int64_t now_tks = qemu_get_clock(vm_clock); int64_t alarm_tks = ns2tks(s->alarm_low_ns | (int64_t)s->alarm_high_ns << 32); qemu_put_be64(f, alarm_tks - now_tks); } }
static void pipe_save( Pipe* pipe, QEMUFile* file ) { if (pipe->service == NULL) { /* pipe->service == NULL means we're still using a PipeConnector */ /* Write a zero to indicate this condition */ qemu_put_byte(file, 0); } else { /* Otherwise, write a '1' then the service name */ qemu_put_byte(file, 1); qemu_put_string(file, pipe->service->name); } /* Now save other common data */ qemu_put_be64(file, pipe->channel); qemu_put_byte(file, (int)pipe->wanted); qemu_put_byte(file, (int)pipe->closed); /* Write 1 + args, if any, or simply 0 otherwise */ if (pipe->args != NULL) { qemu_put_byte(file, 1); qemu_put_string(file, pipe->args); } else { qemu_put_byte(file, 0); } if (pipe->funcs->save) { pipe->funcs->save(pipe->opaque, file); } }
static void pipe_save( Pipe* pipe, QEMUFile* file ) { if (pipe->service == NULL) { qemu_put_byte(file, 0); } else { qemu_put_byte(file, 1); qemu_put_string(file, pipe->service->name); } qemu_put_be32(file, (unsigned int)pipe->channel); qemu_put_byte(file, (int)pipe->wanted); qemu_put_byte(file, (int)pipe->closed); if (pipe->args != NULL) { qemu_put_byte(file, 1); qemu_put_string(file, pipe->args); } else { qemu_put_byte(file, 0); } if (pipe->funcs->save) { pipe->funcs->save(pipe->opaque, file); } }
static void goldfish_fb_save(QEMUFile* f, void* opaque) { struct goldfish_fb_state* s = opaque; DisplaySurface *ds = qemu_console_surface(s->con); qemu_put_be32(f, surface_width(ds)); qemu_put_be32(f, surface_height(ds)); qemu_put_be32(f, surface_stride(ds)); qemu_put_byte(f, 0); qemu_put_be32(f, s->fb_base); qemu_put_byte(f, s->base_valid); qemu_put_byte(f, s->need_update); qemu_put_byte(f, s->need_int); qemu_put_byte(f, s->blank); qemu_put_be32(f, s->int_status); qemu_put_be32(f, s->int_enable); qemu_put_be32(f, s->rotation); qemu_put_be32(f, s->dpi); qemu_put_be32(f, s->format); }
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 smc91c111_save(QEMUFile *f, void *opaque) { smc91c111_state *s = opaque; /* busdev, vc, macaddr and mmio_index are linked to the host state and * initialized when the emulator starts (in smc91c111_init1 below). * Saving/restoring those values is therefore useless and may even be * harmful, so they are omitted. */ qemu_put_be16(f, s->tcr); qemu_put_be16(f, s->rcr); qemu_put_be16(f, s->cr); qemu_put_be16(f, s->ctr); qemu_put_be16(f, s->gpr); qemu_put_be16(f, s->ptr); qemu_put_be16(f, s->ercv); qemu_put_be16(f, s->ephsr); qemu_put_be32(f, s->bank); qemu_put_be32(f, s->packet_num); qemu_put_be32(f, s->tx_alloc); qemu_put_be32(f, s->allocated); qemu_put_be32(f, s->tx_fifo_len); qemu_put_buffer(f, (uint8_t*) s->tx_fifo, sizeof(s->tx_fifo)); qemu_put_be32(f, s->rx_fifo_len); qemu_put_buffer(f, (uint8_t*) s->rx_fifo, sizeof(s->rx_fifo)); qemu_put_be32(f, s->tx_fifo_done_len); qemu_put_buffer(f, (uint8_t*) s->tx_fifo_done, sizeof(s->tx_fifo_done)); /* Packet buffer memory. */ qemu_put_buffer(f, (uint8_t*) s->data, sizeof(s->data)); qemu_put_byte(f, s->int_level); qemu_put_byte(f, s->int_mask); /* macaddr, mmio_index omitted intentionally */ }
static void nvram_writeb (void *opaque, target_phys_addr_t addr, uint32_t val) { ds1225y_t *s = opaque; #ifdef DEBUG_NVRAM printf("nvram: write 0x%x at " TARGET_FMT_lx "\n", val, addr); #endif s->contents[addr] = val & 0xff; if (s->file) { qemu_fseek(s->file, addr, SEEK_SET); qemu_put_byte(s->file, (int)val); qemu_fflush(s->file); } }
/** * save_page_header: Write page header to wire * * If this is the 1st block, it also writes the block identification * * Returns: Number of bytes written * * @f: QEMUFile where to send the data * @block: block that contains the page we want to send * @offset: offset inside the block for the page * in the lower bits, it contains flags */ static size_t save_page_header(QEMUFile *f, RAMBlock *block, ram_addr_t offset) { size_t size; qemu_put_be64(f, offset); size = 8; if (!(offset & RAM_SAVE_FLAG_CONTINUE)) { qemu_put_byte(f, strlen(block->idstr)); qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr)); size += 1 + strlen(block->idstr); } return size; }
static size_t save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset, int cont, int flag) { size_t size; qemu_put_be64(f, offset | cont | flag); size = 8; if (!cont) { qemu_put_byte(f, strlen(block->idstr)); qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr)); size += 1 + strlen(block->idstr); } return size; }
static void eeprom_save(QEMUFile *f, void *opaque) { /* Save EEPROM data. */ unsigned address; eeprom_t *eeprom = (eeprom_t *)opaque; qemu_put_byte(f, eeprom->tick); qemu_put_byte(f, eeprom->address); qemu_put_byte(f, eeprom->command); qemu_put_byte(f, eeprom->writeable); qemu_put_byte(f, eeprom->eecs); qemu_put_byte(f, eeprom->eesk); qemu_put_byte(f, eeprom->eedo); qemu_put_byte(f, eeprom->addrbits); qemu_put_be16(f, eeprom->size); qemu_put_be16(f, eeprom->data); for (address = 0; address < eeprom->size; address++) { qemu_put_be16(f, eeprom->contents[address]); } }
static void slirp_tcp_save(QEMUFile *f, struct tcpcb *tp) { int i; qemu_put_sbe16(f, tp->t_state); for (i = 0; i < TCPT_NTIMERS; i++) qemu_put_sbe16(f, tp->t_timer[i]); qemu_put_sbe16(f, tp->t_rxtshift); qemu_put_sbe16(f, tp->t_rxtcur); qemu_put_sbe16(f, tp->t_dupacks); qemu_put_be16(f, tp->t_maxseg); qemu_put_sbyte(f, tp->t_force); qemu_put_be16(f, tp->t_flags); qemu_put_be32(f, tp->snd_una); qemu_put_be32(f, tp->snd_nxt); qemu_put_be32(f, tp->snd_up); qemu_put_be32(f, tp->snd_wl1); qemu_put_be32(f, tp->snd_wl2); qemu_put_be32(f, tp->iss); qemu_put_be32(f, tp->snd_wnd); qemu_put_be32(f, tp->rcv_wnd); qemu_put_be32(f, tp->rcv_nxt); qemu_put_be32(f, tp->rcv_up); qemu_put_be32(f, tp->irs); qemu_put_be32(f, tp->rcv_adv); qemu_put_be32(f, tp->snd_max); qemu_put_be32(f, tp->snd_cwnd); qemu_put_be32(f, tp->snd_ssthresh); qemu_put_sbe16(f, tp->t_idle); qemu_put_sbe16(f, tp->t_rtt); qemu_put_be32(f, tp->t_rtseq); qemu_put_sbe16(f, tp->t_srtt); qemu_put_sbe16(f, tp->t_rttvar); qemu_put_be16(f, tp->t_rttmin); qemu_put_be32(f, tp->max_sndwnd); qemu_put_byte(f, tp->t_oobflags); qemu_put_byte(f, tp->t_iobc); qemu_put_sbe16(f, tp->t_softerror); qemu_put_byte(f, tp->snd_scale); qemu_put_byte(f, tp->rcv_scale); qemu_put_byte(f, tp->request_r_scale); qemu_put_byte(f, tp->requested_s_scale); qemu_put_be32(f, tp->ts_recent); qemu_put_be32(f, tp->ts_recent_age); qemu_put_be32(f, tp->last_ack_sent); }
static void gic_save(QEMUFile *f, void *opaque) { gic_state *s = (gic_state *)opaque; ARMGICCommonClass *c = ARM_GIC_COMMON_GET_CLASS(s); int i; int j; if (c->pre_save) { c->pre_save(s); } qemu_put_be32(f, s->enabled); for (i = 0; i < s->num_cpu; i++) { qemu_put_be32(f, s->cpu_enabled[i]); for (j = 0; j < GIC_INTERNAL; j++) { qemu_put_be32(f, s->priority1[j][i]); } for (j = 0; j < s->num_irq; j++) { qemu_put_be32(f, s->last_active[j][i]); } qemu_put_be32(f, s->priority_mask[i]); qemu_put_be32(f, s->running_irq[i]); qemu_put_be32(f, s->running_priority[i]); qemu_put_be32(f, s->current_pending[i]); } for (i = 0; i < s->num_irq - GIC_INTERNAL; i++) { qemu_put_be32(f, s->priority2[i]); } for (i = 0; i < s->num_irq; i++) { qemu_put_be32(f, s->irq_target[i]); qemu_put_byte(f, s->irq_state[i].enabled); qemu_put_byte(f, s->irq_state[i].pending); qemu_put_byte(f, s->irq_state[i].active); qemu_put_byte(f, s->irq_state[i].level); qemu_put_byte(f, s->irq_state[i].model); qemu_put_byte(f, s->irq_state[i].trigger); } }