label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void parse_error(JSONParserContext *ctxt, QObject *token, const char *msg, ...){ fprintf(stderr, "parse error: %s\n", msg);} |
0 | 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, S... |
0 | void kvm_arch_update_guest_debug(CPUState *env, struct kvm_guest_debug *dbg){ const uint8_t type_code[] = { [GDB_BREAKPOINT_HW] = 0x0, [GDB_WATCHPOINT_WRITE] = 0x1, [GDB_WATCHPOINT_ACCESS] = 0x3 }; const uint8_t len_code[] = { [1] = 0x0, [2] = 0x1, [4] = 0x3, [8] = 0x2 }; int n; if (kvm_sw_breakpoints_active(env)) dbg-... |
0 | SocketAddress *socket_local_address(int fd, Error **errp){ struct sockaddr_storage ss; socklen_t sslen = sizeof(ss); if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) { error_setg_errno(errp, errno, "%s", "Unable to query local socket address"); return NULL; } return socket_sockaddr_to_address(&ss, sslen, errp);... |
0 | static void eeprom_generate(eeprom24c0x_t *eeprom, ram_addr_t ram_size){ enum { SDR = 0x4, DDR2 = 0x8 } type; uint8_t *spd = eeprom->contents; uint8_t nbanks = 0; uint16_t density = 0; int i; /* work in terms of MB */ ram_size >>= 20; while ((ram_size >= 4) && (nbanks <= 2)) { int sz_log2 = MIN(31 - clz32(ram_size), 14... |
0 | static int virtio_blk_init_pci(PCIDevice *pci_dev){ VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev); VirtIODevice *vdev; if (proxy->class_code != PCI_CLASS_STORAGE_SCSI && proxy->class_code != PCI_CLASS_STORAGE_OTHER) proxy->class_code = PCI_CLASS_STORAGE_SCSI; if (!proxy->block.dinfo) { error_repor... |
0 | void s390_io_interrupt(S390CPU *cpu, uint16_t subchannel_id, uint16_t subchannel_nr, uint32_t io_int_parm, uint32_t io_int_word){ if (kvm_enabled()) { kvm_s390_io_interrupt(cpu, subchannel_id, subchannel_nr, io_int_parm, io_int_word); } else { cpu_inject_io(cpu, subchannel_id, subchannel_nr, io_int_parm, io_int_word); ... |
0 | static void pci_bridge_region_del(PCIBridge *br, PCIBridgeWindows *w){ PCIDevice *pd = PCI_DEVICE(br); PCIBus *parent = pd->bus; memory_region_del_subregion(parent->address_space_io, &w->alias_io); memory_region_del_subregion(parent->address_space_mem, &w->alias_mem); memory_region_del_subregion(parent->address_space_m... |
0 | void bt_l2cap_psm_register(struct bt_l2cap_device_s *dev, int psm, int min_mtu, int (*new_channel)(struct bt_l2cap_device_s *dev, struct bt_l2cap_conn_params_s *params)){ struct bt_l2cap_psm_s *new_psm = l2cap_psm(dev, psm); if (new_psm) { fprintf(stderr, "%s: PSM %04x already registered for device `%s'.\n", __FUNCTION... |
0 | static int check_pow_970 (CPUPPCState *env){ if (env->spr[SPR_HID0] & 0x00600000) return 1; return 0;} |
0 | void do_info_usernet(Monitor *mon){ SlirpState *s; TAILQ_FOREACH(s, &slirp_stacks, entry) { monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name); slirp_connection_info(s->slirp, mon); }} |
0 | static inline void RENAME(rgb16to32)(const uint8_t *src, uint8_t *dst, long src_size){ const uint16_t *end;#if COMPILE_TEMPLATE_MMX const uint16_t *mm_end;#endif uint8_t *d = dst; const uint16_t *s = (const uint16_t*)src; end = s + src_size/2;#if COMPILE_TEMPLATE_MMX __asm__ volatile(PREFETCH" %0"::"m"(*s):"memory"); _... |
0 | int ff_xvmc_field_start(MpegEncContext*s, AVCodecContext *avctx){ struct xvmc_pixfmt_render *last, *next, *render = (struct xvmc_pixfmt_render*)s->current_picture.data[2]; const int mb_block_count = 4 + (1 << s->chroma_format); assert(avctx); if (!render || render->magic_id != AV_XVMC_RENDER_MAGIC || !render->data_bloc... |
0 | int64_t url_fseek(ByteIOContext *s, int64_t offset, int whence){ int64_t offset1; int64_t pos; int force = whence & AVSEEK_FORCE; whence &= ~AVSEEK_FORCE; if(!s) return AVERROR(EINVAL); pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer)); if (whence != SEEK_CUR && whence != SEEK_SET) return AVERROR(EINVAL); i... |
0 | int ff_listen_connect(int fd, const struct sockaddr *addr, socklen_t addrlen, int timeout, URLContext *h){ struct pollfd p = {fd, POLLOUT, 0}; int ret; socklen_t optlen; ff_socket_nonblock(fd, 1); while ((ret = connect(fd, addr, addrlen))) { ret = ff_neterrno(); switch (ret) { case AVERROR(EINTR): if (ff_check_interrup... |
1 | static int get_uint32_equal(QEMUFile *f, void *pv, size_t size){ uint32_t *v = pv; uint32_t v2; qemu_get_be32s(f, &v2); if (*v == v2) { return 0; } return -EINVAL;} |
1 | int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp){ QemuOpts *opts; int fd; opts = qemu_opts_create_nofail(&socket_optslist); switch (remote->kind) { case SOCKET_ADDRESS_KIND_INET: qemu_opt_set(opts, "host", remote->inet->host); qemu_opt_set(opts, "port", remote->inet->port); if (local) { qemu_... |
1 | static void cpu_common_initfn(Object *obj){ CPUState *cpu = CPU(obj); CPUClass *cc = CPU_GET_CLASS(obj); cpu->cpu_index = UNASSIGNED_CPU_INDEX; cpu->gdb_num_regs = cpu->gdb_num_g_regs = cc->gdb_num_core_regs; /* *-user doesn't have configurable SMP topology */ /* the default value is changed by qemu_init_vcpu() for sof... |
1 | static void read_sbr_single_channel_element(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb){ if (get_bits1(gb)) // bs_data_extra skip_bits(gb, 4); // bs_reserved read_sbr_grid(ac, sbr, gb, &sbr->data[0]); read_sbr_dtdf(sbr, gb, &sbr->data[0]); read_sbr_invf(sbr, gb, &sbr->data[0]); read_sbr_envelope(sb... |
1 | static int GLZWDecode(GifState * s, uint8_t * buf, int len){ int l, c, code, oc, fc; uint8_t *sp; if (s->end_code < 0) return 0; l = len; sp = s->sp; oc = s->oc; fc = s->fc; while (sp > s->stack) { *buf++ = *(--sp); if ((--l) == 0) goto the_end; } for (;;) { c = GetCode(s); if (c == s->end_code) { s->end_code = -1; bre... |
1 | bool throttle_is_valid(ThrottleConfig *cfg, Error **errp){ int i; bool bps_flag, ops_flag; bool bps_max_flag, ops_max_flag; bps_flag = cfg->buckets[THROTTLE_BPS_TOTAL].avg && (cfg->buckets[THROTTLE_BPS_READ].avg || cfg->buckets[THROTTLE_BPS_WRITE].avg); ops_flag = cfg->buckets[THROTTLE_OPS_TOTAL].avg && (cfg->buckets[T... |
1 | static void put_ebml_uint(ByteIOContext *pb, unsigned int elementid, uint64_t val){ int i, bytes = 1; while (val >> bytes*8 && bytes < 8) bytes++; put_ebml_id(pb, elementid); put_ebml_num(pb, bytes, 0); for (i = bytes - 1; i >= 0; i--) put_byte(pb, val >> i*8);} |
1 | PCIBus *pci_grackle_init(uint32_t base, qemu_irq *pic){ DeviceState *dev; SysBusDevice *s; GrackleState *d; dev = qdev_create(NULL, "grackle"); qdev_init(dev); s = sysbus_from_qdev(dev); d = FROM_SYSBUS(GrackleState, s); d->host_state.bus = pci_register_bus(&d->busdev.qdev, "pci", pci_grackle_set_irq, pci_grackle_map_i... |
1 | static void xan_unpack(unsigned char *dest, const unsigned char *src, int dest_len){ unsigned char opcode; int size; unsigned char *dest_end = dest + dest_len; while (dest < dest_end) { opcode = *src++; if (opcode < 0xe0) { int size2, back; if ( (opcode & 0x80) == 0 ) { size = opcode & 3; back = ((opcode & 0x60) << 3) ... |
0 | static int adx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ int buf_size = avpkt->size; ADXContext *c = avctx->priv_data; int16_t *samples; const uint8_t *buf = avpkt->data; int num_blocks, ch, ret; if (c->eof) { *got_frame_ptr = 0; return buf_size; } if (!c->header_parsed && bu... |
1 | static inline void RENAME(bgr15ToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, int width){int i; assert(src1==src2);for(i=0; i<width; i++){int d0= ((uint32_t*)src1)[i];int dl= (d0&0x03E07C1F);int dh= ((d0>>5)&0x03E0F81F);int dh2= (dh>>11) + (dh<<21);int d= dh2 + dl;int b= d&0x7F;int r= (d>>10)&0x7F;in... |
1 | static int matroska_parse_cluster_incremental(MatroskaDemuxContext *matroska){ EbmlList *blocks_list; MatroskaBlock *blocks; int i, res; res = ebml_parse(matroska, matroska_cluster_incremental_parsing, &matroska->current_cluster); if (res == 1) { /* New Cluster */ if (matroska->current_cluster_pos) ebml_level_end(matro... |
1 | static int cache_read(URLContext *h, unsigned char *buf, int size){ Context *c= h->priv_data; CacheEntry *entry, *next[2] = {NULL, NULL}; int r; entry = av_tree_find(c->root, &c->logical_pos, cmp, (void**)next); if (!entry) entry = next[0]; if (entry) { int64_t in_block_pos = c->logical_pos - entry->logical_pos; av_ass... |
0 | const AVOption *av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags){ AVClass *c = *(AVClass**)obj; const AVOption *o = NULL; if (c->opt_find && search_flags & AV_OPT_SEARCH_CHILDREN && (o = c->opt_find(obj, name, unit, opt_flags, search_flags))) return o; while (o = av_next_optio... |
0 | static int vcr1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ VCR1Context *const a = avctx->priv_data; AVFrame *const p = data; const uint8_t *bytestream = avpkt->data; const uint8_t *bytestream_end = bytestream + avpkt->size; int i, x, y, ret; if(avpkt->size < 16 + avctx->height + a... |
0 | static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice, unsigned position, unsigned size){ const H264Context *h = avctx->priv_data; struct dxva_context *ctx = avctx->hwaccel_context; unsigned list; memset(slice, 0, sizeof(*slice)); slice->BSNALunitDataLocation = position; slice->SliceBytesInBuff... |
0 | static char* mpjpeg_get_boundary(AVIOContext* pb){ uint8_t *mime_type = NULL; const char *start; const char *end; uint8_t *res = NULL; int len; /* get MIME type, and skip to the first parameter */ av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type); start = mime_type; while (start != NULL && *start != '\0')... |
0 | static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset){ AVPacket pkt1, *pkt = &pkt1; AVStream *st; int read_size, i, ret; int64_t end_time; int64_t filesize, offset, duration; int retry = 0; /* flush packet queue */ flush_packet_queue(ic); for (i = 0; i < ic->nb_streams; i++) { st = ic->streams[... |
1 | int init_put_byte(ByteIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t (*seek)(void *opaque, int64_t offset, int whence)){ s->buffer = buffer; s->buffer... |
1 | static void vc1_decode_skip_blocks(VC1Context *v){ MpegEncContext *s = &v->s; if (!v->s.last_picture.f.data[0]) return; ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END); s->first_slice_line = 1; for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { s->mb_x = 0; init_blo... |
1 | static void psy_3gpp_analyze_channel(FFPsyContext *ctx, int channel, const float *coefs, const FFPsyWindowInfo *wi){ AacPsyContext *pctx = (AacPsyContext*) ctx->model_priv_data; AacPsyChannel *pch = &pctx->ch[channel]; int start = 0; int i, w, g; float desired_bits, desired_pe, delta_pe, reduction, spread_en[128] = {0}... |
1 | decode_coeffs_b_generic(VP56RangeCoder *c, int16_t *coef, int n_coeffs, int is_tx32x32, int is8bitsperpixel, int bpp, unsigned (*cnt)[6][3], unsigned (*eob)[6][2], uint8_t (*p)[6][11], int nnz, const int16_t *scan, const int16_t (*nb)[2], const int16_t *band_counts, const int16_t *qmul){ int i = 0, band = 0, band_left ... |
1 | static void set_pci_devfn(Object *obj, Visitor *v, void *opaque, const char *name, Error **errp){ DeviceState *dev = DEVICE(obj); Property *prop = opaque; uint32_t *ptr = qdev_get_prop_ptr(dev, prop); unsigned int slot, fn, n; Error *local_err = NULL; char *str = (char *)""; if (dev->state != DEV_STATE_CREATED) { error... |
1 | static void error_callback_bh(void *opaque){ Coroutine *co = opaque; qemu_coroutine_enter(co);} |
1 | void *colo_process_incoming_thread(void *opaque){ MigrationIncomingState *mis = opaque; QEMUFile *fb = NULL; QIOChannelBuffer *bioc = NULL; /* Cache incoming device state */ uint64_t total_size; uint64_t value; Error *local_err = NULL; migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE, MIGRATION_STATUS_COLO); fail... |
1 | static int get_uint8(QEMUFile *f, void *pv, size_t size){ uint8_t *v = pv; qemu_get_8s(f, v); return 0;} |
1 | static uint64_t virtio_pci_config_read(void *opaque, hwaddr addr, unsigned size){ VirtIOPCIProxy *proxy = opaque; VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev); uint64_t val = 0; if (addr < config) { return virtio_ioport_read(proxy, addr); } addr -= config... |
1 | int net_init_socket(QemuOpts *opts, const char *name, VLANState *vlan){ if (qemu_opt_get(opts, "fd")) { int fd; if (qemu_opt_get(opts, "listen") || qemu_opt_get(opts, "connect") || qemu_opt_get(opts, "mcast") || qemu_opt_get(opts, "localaddr")) { error_report("listen=, connect=, mcast= and localaddr= is invalid with fd... |
0 | static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ uint8_t *buf = avpkt->data; int buf_size = avpkt->size; DVVideoContext *s = avctx->priv_data; const uint8_t* vsc_pack; int apt, is16_9, ret; const DVprofile *sys; sys = avpriv_dv_frame_profile2(avctx, s->sys, buf, buf_s... |
0 | static int theora_decode_header(AVCodecContext *avctx, GetBitContext gb){ Vp3DecodeContext *s = avctx->priv_data; s->theora = get_bits_long(&gb, 24); av_log(avctx, AV_LOG_INFO, "Theora bitstream version %X\n", s->theora); /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */ /* but previous versions hav... |
1 | static av_cold int init_buffers(SANMVideoContext *ctx){ av_fast_padded_malloc(&ctx->frm0, &ctx->frm0_size, ctx->buf_size); av_fast_padded_malloc(&ctx->frm1, &ctx->frm1_size, ctx->buf_size); av_fast_padded_malloc(&ctx->frm2, &ctx->frm2_size, ctx->buf_size); if (!ctx->version) av_fast_padded_malloc(&ctx->stored_frame, &c... |
1 | int unix_listen_opts(QemuOpts *opts){ struct sockaddr_un un; const char *path = qemu_opt_get(opts, "path"); int sock, fd; sock = socket(PF_UNIX, SOCK_STREAM, 0); if (sock < 0) { perror("socket(unix)"); return -1; } memset(&un, 0, sizeof(un)); un.sun_family = AF_UNIX; if (path && strlen(path)) { snprintf(un.sun_path, si... |
1 | static void bus_add_child(BusState *bus, DeviceState *child){ char name[32]; BusChild *kid = g_malloc0(sizeof(*kid)); if (qdev_hotplug) { assert(bus->allow_hotplug); } kid->index = bus->max_index++; kid->child = child; object_ref(OBJECT(kid->child)); QTAILQ_INSERT_HEAD(&bus->children, kid, sibling); /* This transfers o... |
1 | build_ssdt(GArray *table_data, GArray *linker, AcpiCpuInfo *cpu, AcpiPmInfo *pm, AcpiMiscInfo *misc, PcPciInfo *pci, PcGuestInfo *guest_info){ MachineState *machine = MACHINE(qdev_get_machine()); uint32_t nr_mem = machine->ram_slots; unsigned acpi_cpus = guest_info->apic_id_limit; Aml *ssdt, *sb_scope, *scope, *pkg, *d... |
1 | static void release_delayed_buffers(PerThreadContext *p){ FrameThreadContext *fctx = p->parent; while (p->num_released_buffers > 0) { AVFrame *f = &p->released_buffers[--p->num_released_buffers]; pthread_mutex_lock(&fctx->buffer_mutex); free_progress(f); f->thread_opaque = NULL; f->owner->release_buffer(f->owner, f); p... |
1 | double ff_lpc_calc_ref_coefs_f(LPCContext *s, const float *samples, int len, int order, double *ref){ int i; double signal = 0.0f, avg_err = 0.0f; double autoc[MAX_LPC_ORDER+1] = {0}, error[MAX_LPC_ORDER+1] = {0}; const double a = 0.5f, b = 1.0f - a; /* Apply windowing */ for (i = 0; i < len; i++) { double weight = a -... |
1 | int av_write_trailer(AVFormatContext *s){ int ret, i; for (;; ) { AVPacket pkt; ret = interleave_packet(s, &pkt, NULL, 1); if (ret < 0) //FIXME cleanup needed for ret<0 ? goto fail; if (!ret) break; ret = s->oformat->write_packet(s, &pkt); if (ret >= 0) s->streams[pkt.stream_index]->nb_frames++; av_free_packet(&pkt); i... |
1 | int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags){ AVDictionary *m = *pm; AVDictionaryEntry *tag = av_dict_get(m, key, NULL, flags); char *oldval = NULL; if (!m) m = *pm = av_mallocz(sizeof(*m)); if (tag) { if (flags & AV_DICT_DONT_OVERWRITE) return 0; if (flags & AV_DICT_APPEND) oldval ... |
1 | static void s390_virtio_rng_instance_init(Object *obj){ VirtIORNGS390 *dev = VIRTIO_RNG_S390(obj); object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_RNG); object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); object_property_add_link(obj, "rng", TYPE_RNG_BACKEND, (Object **)&dev->vdev.c... |
1 | static struct omap_sti_s *omap_sti_init(struct omap_target_agent_s *ta, MemoryRegion *sysmem, hwaddr channel_base, qemu_irq irq, omap_clk clk, CharDriverState *chr){ struct omap_sti_s *s = (struct omap_sti_s *) g_malloc0(sizeof(struct omap_sti_s)); s->irq = irq; omap_sti_reset(s); s->chr = chr ?: qemu_chr_new("null", "... |
1 | void cpu_interrupt(CPUArchState *env, int mask){ CPUState *cpu = ENV_GET_CPU(env); env->interrupt_request |= mask; cpu_unlink_tb(cpu);} |
1 | static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr, unsigned int pos){ SubStream *s = &m->substream[substr]; unsigned int mat, channel; for (mat = 0; mat < s->num_primitive_matrices; mat++) if (s->lsb_bypass[mat]) m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp); ... |
1 | static void superh_cpu_initfn(Object *obj){ CPUState *cs = CPU(obj); SuperHCPU *cpu = SUPERH_CPU(obj); CPUSH4State *env = &cpu->env; cs->env_ptr = env; cpu_exec_init(cs, &error_abort); env->movcal_backup_tail = &(env->movcal_backup); if (tcg_enabled()) { sh4_translate_init(); }} |
1 | void ff_estimate_b_frame_motion(MpegEncContext * s, int mb_x, int mb_y){ MotionEstContext * const c= &s->me; const int penalty_factor= c->mb_penalty_factor; int fmin, bmin, dmin, fbmin, bimin, fimin; int type=0; const int xy = mb_y*s->mb_stride + mb_x; init_ref(c, s->new_picture.f.data, s->last_picture.f.data, s->next_... |
1 | xmit_seg(E1000State *s){ uint16_t len, *sp; unsigned int frames = s->tx.tso_frames, css, sofar, n; struct e1000_tx *tp = &s->tx; if (tp->tse && tp->cptse) { css = tp->ipcss; DBGOUT(TXSUM, "frames %d size %d ipcss %d\n", frames, tp->size, css); if (tp->ip) {// IPv4 cpu_to_be16wu((uint16_t *)(tp->data+css+2), tp->size - ... |
1 | static void omap_timer_clk_setup(struct omap_mpu_timer_s *timer){ omap_clk_adduser(timer->clk, qemu_allocate_irqs(omap_timer_clk_update, timer, 1)[0]); timer->rate = omap_clk_getrate(timer->clk);} |
1 | static int drive_init(struct drive_opt *arg, int snapshot, QEMUMachine *machine){ char buf[128]; char file[1024]; char devname[128]; char serial[21]; const char *mediastr = ""; BlockInterfaceType type; enum { MEDIA_DISK, MEDIA_CDROM } media; int bus_id, unit_id; int cyls, heads, secs, translation; BlockDriverState *bdr... |
1 | static void qvirtio_pci_set_status(QVirtioDevice *d, uint8_t status){ QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d; qpci_io_writeb(dev->pdev, dev->addr + VIRTIO_PCI_STATUS, status);} |
1 | static void test_acpi_piix4_tcg_cphp(void){ test_data data; memset(&data, 0, sizeof(data)); data.machine = MACHINE_PC; data.variant = ".cphp"; test_acpi_one("-smp 2,cores=3,sockets=2,maxcpus=6", &data); free_test_data(&data);} |
1 | void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, int64_t bps_wr, int64_t iops, int64_t iops_rd, int64_t iops_wr, bool has_bps_max, int64_t bps_max, bool has_bps_rd_max, int64_t bps_rd_max, bool has_bps_wr_max, int64_t bps_wr_max, bool has_iops_max, int64_t iops_max, bool has_iops_rd_max, ... |
0 | static void setup_frame(int sig, struct target_sigaction *ka, target_sigset_t *set, CPUM68KState *env){ struct target_sigframe *frame; abi_ulong frame_addr; abi_ulong retcode_addr; abi_ulong sc_addr; int err = 0; int i; frame_addr = get_sigframe(ka, env, sizeof *frame); if (!lock_user_struct(VERIFY_WRITE, frame, frame_... |
0 | do_socket_read(GIOChannel *source, GIOCondition condition, gpointer data){ int rv; int dwSendLength; int dwRecvLength; uint8_t pbRecvBuffer[APDUBufSize]; static uint8_t pbSendBuffer[APDUBufSize]; VReaderStatus reader_status; VReader *reader = NULL; static VSCMsgHeader mhHeader; VSCMsgError *error_msg; GError *err = NUL... |
0 | static size_t buffered_get_rate_limit(void *opaque){ QEMUFileBuffered *s = opaque; return s->xfer_limit;} |
0 | static void check_time(int wiggle){ struct tm start, date[4], end; struct tm *datep; time_t ts; /* * This check assumes a few things. First, we cannot guarantee that we get * a consistent reading from the wall clock because we may hit an edge of * the clock while reading. To work around this, we read four clock reading... |
0 | aio_ctx_finalize(GSource *source){ AioContext *ctx = (AioContext *) source; thread_pool_free(ctx->thread_pool);#ifdef CONFIG_LINUX_AIO if (ctx->linux_aio) { laio_detach_aio_context(ctx->linux_aio, ctx); laio_cleanup(ctx->linux_aio); ctx->linux_aio = NULL; }#endif qemu_lockcnt_lock(&ctx->list_lock); assert(!qemu_lockcnt... |
0 | static void bdrv_stats_iter(QObject *data, void *opaque){ QDict *qdict; Monitor *mon = opaque; qdict = qobject_to_qdict(data); monitor_printf(mon, "%s:", qdict_get_str(qdict, "device")); qdict = qobject_to_qdict(qdict_get(qdict, "stats")); monitor_printf(mon, " rd_bytes=%" PRId64 " wr_bytes=%" PRId64 " rd_operations=%"... |
0 | static int nbd_send_negotiate(NBDClient *client){ int csock = client->sock; char buf[8 + 8 + 8 + 128]; int rc; const int myflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_TRIM | NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA); /* Negotiation header without options: [ 0 .. 7] passwd ("NBDMAGIC") [ 8 .. 15] magic (NBD_CLIENT_MAGIC)... |
0 | void tcg_gen_mb(TCGBar mb_type){ if (parallel_cpus) { tcg_gen_op1(INDEX_op_mb, mb_type); }} |
0 | void *virtqueue_alloc_element(size_t sz, unsigned out_num, unsigned in_num){ VirtQueueElement *elem; size_t in_addr_ofs = QEMU_ALIGN_UP(sz, __alignof__(elem->in_addr[0])); size_t out_addr_ofs = in_addr_ofs + in_num * sizeof(elem->in_addr[0]); size_t out_addr_end = out_addr_ofs + out_num * sizeof(elem->out_addr[0]); siz... |
0 | static int usb_serial_initfn(USBDevice *dev){ USBSerialState *s = DO_UPCAST(USBSerialState, dev, dev); s->dev.speed = USB_SPEED_FULL; if (!s->cs) { error_report("Property chardev is required"); return -1; } qemu_chr_add_handlers(s->cs, usb_serial_can_read, usb_serial_read, usb_serial_event, s); usb_serial_handle_reset(... |
0 | DeviceState *nand_init(BlockDriverState *bdrv, int manf_id, int chip_id){ DeviceState *dev; if (nand_flash_ids[chip_id].size == 0) { hw_error("%s: Unsupported NAND chip ID.\n", __FUNCTION__); } dev = DEVICE(object_new(TYPE_NAND)); qdev_prop_set_uint8(dev, "manufacturer_id", manf_id); qdev_prop_set_uint8(dev, "chip_id",... |
0 | static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)#elsestatic void host_alarm_handler(int host_signum)#endif{#if 0#define DISP_FREQ 1000 { static int64_t delta_min = INT64_MAX; static int64_t delta_max, delta_cum, last_clock, delta, ti; static int count; ti... |
0 | static bool get_phys_addr_lpae(CPUARMState *env, target_ulong address, int access_type, ARMMMUIdx mmu_idx, hwaddr *phys_ptr, MemTxAttrs *txattrs, int *prot, target_ulong *page_size_ptr, uint32_t *fsr){ ARMCPU *cpu = arm_env_get_cpu(env); CPUState *cs = CPU(cpu); /* Read an LPAE long-descriptor translation table. */ MMU... |
0 | static int openfile(char *name, int flags, int growable){if (bs) {fprintf(stderr, "file open already, try 'help close'\n");return 1;}bs = bdrv_new("hda");if (!bs)return 1;if (growable) {flags |= BDRV_O_FILE;}if (bdrv_open(bs, name, flags) == -1) {fprintf(stderr, "%s: can't open device %s\n", progname, name);bs = NULL;r... |
0 | static void visit_nested_struct(Visitor *v, void **native, Error **errp){ visit_type_UserDefNested(v, (UserDefNested **)native, NULL, errp);} |
0 | static uint64_t bmdma_read(void *opaque, target_phys_addr_t addr, unsigned size){ BMDMAState *bm = opaque; uint32_t val; if (size != 1) { return ((uint64_t)1 << (size * 8)) - 1; } switch(addr & 3) { case 0: val = bm->cmd; break; case 2: val = bm->status; break; default: val = 0xff; break; }#ifdef DEBUG_IDE printf("bmdm... |
0 | static void palmte_init(MachineState *machine){ const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; const char *initrd_filename = machine->initrd_filename; MemoryRegion *address_space_mem = get_system_memory(); struct omap_mpu_state_s *mpu; int flash_size = 0x00... |
0 | void configure_icount(const char *option){ vmstate_register(NULL, 0, &vmstate_timers, &timers_state); if (!option) return; if (strcmp(option, "auto") != 0) { icount_time_shift = strtol(option, NULL, 0); use_icount = 1; return; } use_icount = 2; /* 125MIPS seems a reasonable initial guess at the guest speed. It will be ... |
0 | struct omap_mmc_s *omap_mmc_init(hwaddr base, MemoryRegion *sysmem, BlockDriverState *bd, qemu_irq irq, qemu_irq dma[], omap_clk clk){ struct omap_mmc_s *s = (struct omap_mmc_s *) g_malloc0(sizeof(struct omap_mmc_s)); s->irq = irq; s->dma = dma; s->clk = clk; s->lines = 1;/* TODO: needs to be settable per-board */ s->r... |
0 | static int v9fs_synth_utimensat(FsContext *fs_ctx, V9fsPath *path, const struct timespec *buf){ errno = EPERM; return 0;} |
0 | static int monitor_fprintf(FILE *stream, const char *fmt, ...){ va_list ap; va_start(ap, fmt); monitor_vprintf((Monitor *)stream, fmt, ap); va_end(ap); return 0;} |
0 | static void hls_transform_unit(HEVCContext *s, int x0, int y0, int xBase, int yBase, int cb_xBase, int cb_yBase, int log2_cb_size, int log2_trafo_size, int trafo_depth, int blk_idx){ HEVCLocalContext *lc = &s->HEVClc; if (lc->cu.pred_mode == MODE_INTRA) { int trafo_size = 1 << log2_trafo_size; ff_hevc_set_neighbour_ava... |
0 | static int tgv_decode_inter(TgvContext *s, AVFrame *frame, const uint8_t *buf, const uint8_t *buf_end){ int num_mvs; int num_blocks_raw; int num_blocks_packed; int vector_bits; int i,j,x,y; GetBitContext gb; int mvbits; const uint8_t *blocks_raw; if(buf_end - buf < 12) return AVERROR_INVALIDDATA; num_mvs = AV_RL16(&buf... |
1 | void FUNCC(ff_h264_luma_dc_dequant_idct)(int16_t *_output, int16_t *_input, int qmul){#define stride 16 int i; int temp[16]; static const uint8_t x_offset[4]={0, 2*stride, 8*stride, 10*stride}; dctcoef *input = (dctcoef*)_input; dctcoef *output = (dctcoef*)_output; for(i=0; i<4; i++){ const int z0= input[4*i+0] + input... |
1 | static uint64_t qemu_rdma_make_wrid(uint64_t wr_id, uint64_t index, uint64_t chunk){ uint64_t result = wr_id & RDMA_WRID_TYPE_MASK; result |= (index << RDMA_WRID_BLOCK_SHIFT); result |= (chunk << RDMA_WRID_CHUNK_SHIFT); return result;} |
1 | static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs, Error **errp){ Error *local_err = NULL; BlockMeasureInfo *info; uint64_t required = 0; /* bytes that contribute to required size */ uint64_t virtual_size; /* disk size as seen by guest */ uint64_t refcount_bits; uint64_t l2_tables; size_t c... |
0 | static target_ulong disas_insn(DisasContext *s, CPUState *cpu){ CPUX86State *env = cpu->env_ptr; int b, prefixes; int shift; TCGMemOp ot, aflag, dflag; int modrm, reg, rm, mod, op, opreg, val; target_ulong next_eip, tval; int rex_w, rex_r; target_ulong pc_start = s->base.pc_next; s->pc_start = s->pc = pc_start; prefixe... |
0 | static int kvm_mce_in_exception(CPUState *env){ struct kvm_msr_entry msr_mcg_status = { .index = MSR_MCG_STATUS, }; int r; r = kvm_get_msr(env, &msr_mcg_status, 1); if (r == -1 || r == 0) { return -1; } return !!(msr_mcg_status.data & MCG_STATUS_MCIP);} |
0 | static void count_cpreg(gpointer key, gpointer opaque){ ARMCPU *cpu = opaque; uint64_t regidx; const ARMCPRegInfo *ri; regidx = *(uint32_t *)key; ri = get_arm_cp_reginfo(cpu->cp_regs, regidx); if (!(ri->type & ARM_CP_NO_MIGRATE)) { cpu->cpreg_array_len++; }} |
0 | static inline uint32_t efsctsiz(uint32_t val){ CPU_FloatU u; u.l = val; /* NaN are not treated the same way IEEE 754 does */ if (unlikely(float32_is_nan(u.f))) return 0; return float32_to_int32_round_to_zero(u.f, &env->vec_status);} |
0 | static void scsi_unrealize(SCSIDevice *s, Error **errp){ scsi_device_purge_requests(s, SENSE_CODE(NO_SENSE)); blockdev_mark_auto_del(s->conf.blk);} |
0 | int slirp_is_inited(void){ return slirp_inited;} |
0 | int pit_get_gate(PITState *pit, int channel){ PITChannelState *s = &pit->channels[channel]; return s->gate;} |
0 | void pci_register_bar(PCIDevice *pci_dev, int region_num, uint8_t type, MemoryRegion *memory){ PCIIORegion *r; uint32_t addr; /* offset in pci config space */ uint64_t wmask; pcibus_t size = memory_region_size(memory); assert(region_num >= 0); assert(region_num < PCI_NUM_REGIONS); if (size & (size-1)) { fprintf(stderr,... |
0 | static int configure_accelerator(void){ const char *p = NULL; char buf[10]; int i, ret; bool accel_initalised = 0; bool init_failed = 0; QemuOptsList *list = qemu_find_opts("machine"); if (!QTAILQ_EMPTY(&list->head)) { p = qemu_opt_get(QTAILQ_FIRST(&list->head), "accel"); } if (p == NULL) { /* Use the default "accelera... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.