label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void do_commit(Monitor *mon, const QDict *qdict){ int all_devices; DriveInfo *dinfo; const char *device = qdict_get_str(qdict, "device"); all_devices = !strcmp(device, "all"); TAILQ_FOREACH(dinfo, &drives, next) { if (!all_devices) if (strcmp(bdrv_get_device_name(dinfo->bdrv), device)) continue; bdrv_commit(dinf... |
0 | long do_sigreturn(CPUPPCState *env){ struct target_sigcontext *sc = NULL; struct target_mcontext *sr = NULL; target_ulong sr_addr = 0, sc_addr; sigset_t blocked; target_sigset_t set; sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE; if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) goto sigsegv;#if defined(TARGET_PPC64) set.... |
0 | int kvm_arch_irqchip_create(MachineState *ms, KVMState *s){ int ret; if (machine_kernel_irqchip_split(ms)) { ret = kvm_vm_enable_cap(s, KVM_CAP_SPLIT_IRQCHIP, 0, 24); if (ret) { error_report("Could not enable split irqchip mode: %s\n", strerror(-ret)); exit(1); } else { DPRINTF("Enabled KVM_CAP_SPLIT_IRQCHIP\n"); kvm_s... |
0 | void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns, int64_t grow, int64_t shrink, Error **errp){ /* No thread synchronization here, it doesn't matter if an incorrect value * is used once. */ ctx->poll_max_ns = max_ns; ctx->poll_ns = 0; ctx->poll_grow = grow; ctx->poll_shrink = shrink; aio_notify(ctx);} |
0 | static void rtas_ibm_change_msi(PowerPCCPU *cpu, sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ uint32_t config_addr = rtas_ld(args, 0); uint64_t buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2); unsigned int func = rtas_ld(args, 3); unsigned i... |
0 | START_TEST(simple_number){ int i; struct { const char *encoded; int64_t decoded; } test_cases[] = { { "0", 0 }, { "1234", 1234 }, { "1", 1 }, { "-32", -32 }, { "-0", 0 }, { }, }; for (i = 0; test_cases[i].encoded; i++) { QObject *obj; QInt *qint; obj = qobject_from_json(test_cases[i].encoded); fail_unless(obj != NULL);... |
0 | static int v410_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void *data){ AVFrame *pic = data; uint8_t *dst = buf; uint16_t *y, *u, *v; uint32_t val; int i, j; int output_size = 0; if (buf_size < avctx->width * avctx->height * 3) { av_log(avctx, AV_LOG_ERROR, "Out buffer is too small.\n"); return AVE... |
0 | static void exynos4210_rtc_write(void *opaque, target_phys_addr_t offset, uint64_t value, unsigned size){ Exynos4210RTCState *s = (Exynos4210RTCState *)opaque; switch (offset) { case INTP: if (value & INTP_ALM_ENABLE) { qemu_irq_lower(s->alm_irq); s->reg_intp &= (~INTP_ALM_ENABLE); } if (value & INTP_TICK_ENABLE) { qem... |
0 | static void dummy_m68k_init(QEMUMachineInitArgs *args){ ram_addr_t ram_size = args->ram_size; const char *cpu_model = args->cpu_model; const char *kernel_filename = args->kernel_filename; CPUM68KState *env; MemoryRegion *address_space_mem = get_system_memory(); MemoryRegion *ram = g_new(MemoryRegion, 1); int kernel_siz... |
0 | static void memory_dump(int count, int format, int wsize, target_phys_addr_t addr, int is_physical){ CPUState *env; int nb_per_line, l, line_size, i, max_digits, len; uint8_t buf[16]; uint64_t v; if (format == 'i') { int flags; flags = 0; env = mon_get_cpu(); if (!env && !is_physical) return;#ifdef TARGET_I386 if (wsiz... |
0 | void ide_sector_write(IDEState *s){ int64_t sector_num; int n; s->status = READY_STAT | SEEK_STAT | BUSY_STAT; sector_num = ide_get_sector(s);#if defined(DEBUG_IDE) printf("sector=%" PRId64 "\n", sector_num);#endif n = s->nsector; if (n > s->req_nb_sectors) { n = s->req_nb_sectors; } if (!ide_sect_range_ok(s, sector_nu... |
0 | int bdrv_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors){ return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);} |
0 | static ssize_t tap_receive_iov(void *opaque, const struct iovec *iov, int iovcnt){ TAPState *s = opaque; ssize_t len; do { len = writev(s->fd, iov, iovcnt); } while (len == -1 && (errno == EINTR || errno == EAGAIN)); return len;} |
0 | static void qemu_coroutine_thread_cleanup(void *opaque){ CoroutineThreadState *s = opaque; Coroutine *co; Coroutine *tmp; QLIST_FOREACH_SAFE(co, &s->pool, pool_next, tmp) { g_free(DO_UPCAST(CoroutineUContext, base, co)->stack); g_free(co); } g_free(s);} |
0 | static int ioh3420_initfn(PCIDevice *d){ PCIBridge* br = DO_UPCAST(PCIBridge, dev, d); PCIEPort *p = DO_UPCAST(PCIEPort, br, br); PCIESlot *s = DO_UPCAST(PCIESlot, port, p); int rc; int tmp; rc = pci_bridge_initfn(d); if (rc < 0) { return rc; } d->config[PCI_REVISION_ID] = PCI_DEVICE_ID_IOH_REV; pcie_port_init_reg(d); ... |
0 | static inline bool cpu_handle_interrupt(CPUState *cpu, TranslationBlock **last_tb){ CPUClass *cc = CPU_GET_CLASS(cpu); int interrupt_request = cpu->interrupt_request; if (unlikely(interrupt_request)) { if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) { /* Mask out external interrupts for this step. */ interrupt_req... |
0 | void scsi_req_cancel(SCSIRequest *req){ trace_scsi_req_cancel(req->dev->id, req->lun, req->tag); if (!req->enqueued) { return; } scsi_req_ref(req); scsi_req_dequeue(req); req->io_canceled = true; if (req->aiocb) { bdrv_aio_cancel(req->aiocb); }} |
0 | static void test_visitor_in_int(TestInputVisitorData *data, const void *unused){ int64_t res = 0, value = -42; Visitor *v; v = visitor_input_test_init(data, "%" PRId64, value); visit_type_int(v, NULL, &res, &error_abort); g_assert_cmpint(res, ==, value);} |
0 | static int onenand_initfn(SysBusDevice *sbd){ DeviceState *dev = DEVICE(sbd); OneNANDState *s = ONE_NAND(dev); uint32_t size = 1 << (24 + ((s->id.dev >> 4) & 7)); void *ram; s->base = (hwaddr)-1; s->rdy = NULL; s->blocks = size >> BLOCK_SHIFT; s->secs = size >> 9; s->blockwp = g_malloc(s->blocks); s->density_mask = (s-... |
0 | static void pxa2xx_lcdc_dma0_redraw_rot90(PXA2xxLCDState *s, hwaddr addr, int *miny, int *maxy){ DisplaySurface *surface = qemu_console_surface(s->con); int src_width, dest_width; drawfn fn = NULL; if (s->dest_width) fn = s->line_fn[s->transp][s->bpp]; if (!fn) return; src_width = (s->xres + 3) & ~3; /* Pad to a 4 pixe... |
0 | static BlockBackend *bdrv_first_blk(BlockDriverState *bs){ BdrvChild *child; QLIST_FOREACH(child, &bs->parents, next_parent) { if (child->role == &child_root) { assert(bs->blk); return child->opaque; } } assert(!bs->blk); return NULL;} |
0 | static void s390_print_cpu_model_list_entry(gpointer data, gpointer user_data){ CPUListState *s = user_data; const S390CPUClass *scc = S390_CPU_CLASS((ObjectClass *)data); char *name = g_strdup(object_class_get_name((ObjectClass *)data)); const char *details = ""; if (scc->is_static) { details = "(static, migration-saf... |
0 | static void simple_varargs(void){ QObject *embedded_obj; QObject *obj; LiteralQObject decoded = QLIT_QLIST(((LiteralQObject[]){ QLIT_QINT(1), QLIT_QINT(2), QLIT_QLIST(((LiteralQObject[]){ QLIT_QINT(32), QLIT_QINT(42), {}})), {}})); embedded_obj = qobject_from_json("[32, 42]"); g_assert(embedded_obj != NULL); obj = qobj... |
0 | static void add_device_config(int type, const char *cmdline){ struct device_config *conf; conf = qemu_mallocz(sizeof(*conf)); conf->type = type; conf->cmdline = cmdline; TAILQ_INSERT_TAIL(&device_configs, conf, next);} |
0 | static int compand_nodelay(AVFilterContext *ctx, AVFrame *frame){ CompandContext *s = ctx->priv; AVFilterLink *inlink = ctx->inputs[0]; const int channels = inlink->channels; const int nb_samples = frame->nb_samples; AVFrame *out_frame; int chan, i; if (av_frame_is_writable(frame)) { out_frame = frame; } else { out_fra... |
0 | static int get_sot(Jpeg2000DecoderContext *s, int n){ Jpeg2000TilePart *tp; uint16_t Isot; uint32_t Psot; uint8_t TPsot; if (bytestream2_get_bytes_left(&s->g) < 8) return AVERROR_INVALIDDATA; s->curtileno = 0; Isot = bytestream2_get_be16u(&s->g); // Isot if (Isot >= s->numXtiles * s->numYtiles) return AVERROR_INVALIDDA... |
0 | int MPV_encode_picture(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ MpegEncContext *s = avctx->priv_data; AVFrame *pic_arg = data; int i, stuffing_count; for(i=0; i<avctx->thread_count; i++){ int start_y= s->thread_context[i]->start_mb_y; int end_y= s->thread_context[i]-> end_mb_y; int h= s->mb... |
0 | static int rtc_load_td(QEMUFile *f, void *opaque, int version_id){ RTCState *s = opaque; if (version_id != 1) return -EINVAL; s->irq_coalesced = qemu_get_be32(f); s->period = qemu_get_be32(f); rtc_coalesced_timer_update(s); return 0;} |
0 | static GtkWidget *gd_create_menu_view(GtkDisplayState *s, GtkAccelGroup *accel_group){ GSList *group = NULL; GtkWidget *view_menu; GtkWidget *separator; int i; view_menu = gtk_menu_new(); gtk_menu_set_accel_group(GTK_MENU(view_menu), accel_group); s->full_screen_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_FULLS... |
0 | static int v9fs_synth_readdir_r(FsContext *ctx, V9fsFidOpenState *fs, struct dirent *entry, struct dirent **result){ int ret; V9fsSynthOpenState *synth_open = fs->private; V9fsSynthNode *node = synth_open->node; ret = v9fs_synth_get_dentry(node, entry, result, synth_open->offset); if (!ret && *result != NULL) { synth_o... |
0 | static ssize_t vnc_tls_push(gnutls_transport_ptr_t transport, const void *data, size_t len) { struct VncState *vs = (struct VncState *)transport; int ret; retry: ret = send(vs->csock, data, len, 0); if (ret < 0) {if (errno == EINTR) goto retry;return -1; } return ret;} |
0 | void aio_context_release(AioContext *ctx){ qemu_rec_mutex_unlock(&ctx->lock);} |
0 | static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap){ QObject *key = NULL, *token = NULL, *value, *peek; JSONParserContext saved_ctxt = parser_context_save(ctxt); peek = parser_context_peek_token(ctxt); if (peek == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } key = parse_value(ctxt,... |
0 | gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb, int search_pc){ DisasContext ctx; target_ulong pc_start; uint16_t *gen_opc_end; CPUBreakpoint *bp; int j, lj = -1; int num_insns; int max_insns; if (search_pc && loglevel) fprintf (logfile, "search pc %d\n", search_pc); pc_start = tb->pc; /* Leave som... |
0 | static void *nbd_client_thread(void *arg){ int fd = *(int *)arg; off_t size; size_t blocksize; uint32_t nbdflags; int sock; int ret; pthread_t show_parts_thread; do { sock = unix_socket_outgoing(sockpath); if (sock == -1) { goto out; } } while (sock == -1); ret = nbd_receive_negotiate(sock, NULL, &nbdflags, &size, &blo... |
0 | static void gen_addq(DisasContext *s, TCGv val, int rlow, int rhigh){ TCGv tmp; TCGv tmpl; TCGv tmph; /* Load 64-bit value rd:rn. */ tmpl = load_reg(s, rlow); tmph = load_reg(s, rhigh); tmp = tcg_temp_new(TCG_TYPE_I64); tcg_gen_concat_i32_i64(tmp, tmpl, tmph); dead_tmp(tmpl); dead_tmp(tmph); tcg_gen_add_i64(val, val, t... |
0 | static void onenand_reset(OneNANDState *s, int cold){ memset(&s->addr, 0, sizeof(s->addr)); s->command = 0; s->count = 1; s->bufaddr = 0; s->config[0] = 0x40c0; s->config[1] = 0x0000; onenand_intr_update(s); qemu_irq_raise(s->rdy); s->status = 0x0000; s->intstatus = cold ? 0x8080 : 0x8010; s->unladdr[0] = 0; s->unladdr... |
0 | static void qpi_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val){} |
0 | static void RENAME(yuv2bgr24_1)(SwsContext *c, const uint16_t *buf0, const uint16_t *ubuf0, const uint16_t *ubuf1, const uint16_t *vbuf0, const uint16_t *vbuf1, const uint16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, enum PixelFormat dstFormat, int flags, int y){ const uint16_t *buf1= buf0; //FIXME needed for RGB1... |
0 | static void asf_build_simple_index(AVFormatContext *s, int stream_index){ ff_asf_guid g; ASFContext *asf = s->priv_data; int64_t current_pos= avio_tell(s->pb); int i; avio_seek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET); ff_get_guid(s->pb, &g); /* the data object can be followed by other top-leve... |
0 | void spapr_drc_attach(sPAPRDRConnector *drc, DeviceState *d, void *fdt, int fdt_start_offset, Error **errp){ trace_spapr_drc_attach(spapr_drc_index(drc)); if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) { error_setg(errp, "an attached device is still awaiting release"); return; } if (spapr_drc_type(drc) ... |
0 | void qxl_guest_bug(PCIQXLDevice *qxl, const char *msg, ...){#if SPICE_INTERFACE_QXL_MINOR >= 1 qxl_send_events(qxl, QXL_INTERRUPT_ERROR);#endif if (qxl->guestdebug) { va_list ap; va_start(ap, msg); fprintf(stderr, "qxl-%d: guest bug: ", qxl->id); vfprintf(stderr, msg, ap); fprintf(stderr, "\n"); va_end(ap); }} |
0 | static void rtas_get_time_of_day(sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ struct tm tm; if (nret != 8) { rtas_st(rets, 0, -3); return; } qemu_get_timedate(&tm, spapr->rtc_offset); rtas_st(rets, 0, 0); /* Success */ rtas_st(rets, 1, tm.tm_year + 1900)... |
0 | static void qmp_input_type_uint64(Visitor *v, const char *name, uint64_t *obj, Error **errp){ /* FIXME: qobject_to_qint mishandles values over INT64_MAX */ QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name, true, errp); QInt *qint; if (!qobj) { return; } qint = qobject_to_qint(qobj); if (... |
0 | static int do_info(Monitor *mon, const QDict *qdict, QObject **ret_data){ const mon_cmd_t *cmd; const char *item = qdict_get_try_str(qdict, "item"); if (!item) { goto help; } for (cmd = info_cmds; cmd->name != NULL; cmd++) { if (compare_cmd(item, cmd->name)) break; } if (cmd->name == NULL) { goto help; } if (monitor_ha... |
0 | int tcp_fconnect(struct socket *so){ Slirp *slirp = so->slirp; int ret=0; DEBUG_CALL("tcp_fconnect"); DEBUG_ARG("so = %p", so); if( (ret = so->s = qemu_socket(AF_INET,SOCK_STREAM,0)) >= 0) { int opt, s=so->s; struct sockaddr_in addr; qemu_set_nonblock(s); socket_set_fast_reuse(s); opt = 1; qemu_setsockopt(s, SOL_SOCKET... |
0 | int cpu_watchpoint_insert(CPUState *cpu, vaddr addr, vaddr len, int flags, CPUWatchpoint **watchpoint){ CPUWatchpoint *wp; /* forbid ranges which are empty or run off the end of the address space */ if (len == 0 || (addr + len - 1) <= addr) { error_report("tried to set invalid watchpoint at %" VADDR_PRIx ", len=%" VADD... |
0 | static int unix_connect_saddr(UnixSocketAddress *saddr, NonBlockingConnectHandler *callback, void *opaque, Error **errp){ struct sockaddr_un un; ConnectState *connect_state = NULL; int sock, rc; if (saddr->path == NULL) { error_setg(errp, "unix connect: no path specified"); return -1; } sock = qemu_socket(PF_UNIX, SOCK... |
1 | void qemu_thread_create(QemuThread *thread, void *(*start_routine)(void *), void *arg, int mode){ HANDLE hThread; assert(mode == QEMU_THREAD_DETACHED); struct QemuThreadData *data; qemu_thread_init(); data = g_malloc(sizeof *data); data->thread = thread; data->start_routine = start_routine; data->arg = arg; hThread = (... |
1 | uint32_t kvm_arch_get_supported_cpuid(KVMState *s, uint32_t function, uint32_t index, int reg){ struct kvm_cpuid2 *cpuid; uint32_t ret = 0; uint32_t cpuid_1_edx; bool found = false; cpuid = get_supported_cpuid(s); struct kvm_cpuid_entry2 *entry = cpuid_find_entry(cpuid, function, index); if (entry) { found = true; ret ... |
1 | static uint16_t handle_write_event_buf(SCLPEventFacility *ef, EventBufferHeader *event_buf, SCCB *sccb){ uint16_t rc; BusChild *kid; SCLPEvent *event; SCLPEventClass *ec; QTAILQ_FOREACH(kid, &ef->sbus.qbus.children, sibling) { DeviceState *qdev = kid->child; event = (SCLPEvent *) qdev; ec = SCLP_EVENT_GET_CLASS(event);... |
1 | static int mpl2_probe(AVProbeData *p){ int i; char c; int64_t start, end; const unsigned char *ptr = p->buf; const unsigned char *ptr_end = ptr + p->buf_size; for (i = 0; i < 2; i++) { if (sscanf(ptr, "[%"SCNd64"][%"SCNd64"]%c", &start, &end, &c) != 3 && sscanf(ptr, "[%"SCNd64"][]%c", &start, &c) != 2) return 0; ptr +=... |
1 | static DWORD WINAPI do_suspend(LPVOID opaque){ GuestSuspendMode *mode = opaque; DWORD ret = 0; if (!SetSuspendState(*mode == GUEST_SUSPEND_MODE_DISK, TRUE, TRUE)) { slog("failed to suspend guest, %s", GetLastError()); ret = -1; } g_free(mode); return ret;} |
1 | void qmp_block_commit(const char *device, bool has_base, const char *base, bool has_top, const char *top, bool has_backing_file, const char *backing_file, bool has_speed, int64_t speed, Error **errp){ BlockDriverState *bs; BlockDriverState *base_bs, *top_bs; AioContext *aio_context; Error *local_err = NULL; /* This wil... |
1 | static target_ulong compute_tlbie_rb(target_ulong v, target_ulong r, target_ulong pte_index){ target_ulong rb, va_low; rb = (v & ~0x7fULL) << 16; /* AVA field */ va_low = pte_index >> 3; if (v & HPTE64_V_SECONDARY) { va_low = ~va_low; } /* xor vsid from AVA */ if (!(v & HPTE64_V_1TB_SEG)) { va_low ^= v >> 12; } else { ... |
1 | static void toright(unsigned char *dst[3], unsigned char *src[3], int dststride[3], int srcstride[3], int w, int h, struct vf_priv_s* p){ int k; for (k = 0; k < 3; k++) { unsigned char* fromL = src[k]; unsigned char* fromR = src[k]; unsigned char* to = dst[k]; int src = srcstride[k]; int dst = dststride[k]; int ss; uns... |
1 | static int xan_huffman_decode(uint8_t *dest, int dest_len, const uint8_t *src, int src_len){ uint8_t byte = *src++; uint8_t ival = byte + 0x16; const uint8_t * ptr = src + byte*2; int ptr_len = src_len - 1 - byte*2; uint8_t val = ival; uint8_t *dest_end = dest + dest_len; uint8_t *dest_start = dest; int ret; GetBitCont... |
1 | static int ram_load(QEMUFile *f, void *opaque, int version_id){ int flags = 0, ret = 0, invalid_flags = 0; static uint64_t seq_iter; int len = 0; /* * If system is running in postcopy mode, page inserts to host memory must * be atomic */ bool postcopy_running = postcopy_state_get() >= POSTCOPY_INCOMING_LISTENING; /* AD... |
0 | static int tak_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *pkt){ TAKDecContext *s = avctx->priv_data; AVFrame *frame = data; ThreadFrame tframe = { .f = data }; GetBitContext *gb = &s->gb; int chan, i, ret, hsize; if (pkt->size < TAK_MIN_FRAME_HEADER_BYTES) return AVERROR_INVALIDDATA; ... |
1 | static BlockBackend *img_open_opts(const char *optstr, QemuOpts *opts, int flags, bool writethrough, bool quiet, bool force_share){ QDict *options; Error *local_err = NULL; BlockBackend *blk; options = qemu_opts_to_qdict(opts, NULL); if (force_share) { if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE) && !qdict_get_bool(... |
1 | static void qmp_input_type_bool(Visitor *v, bool *obj, const char *name, Error **errp){ QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name, true); if (!qobj || qobject_type(qobj) != QTYPE_QBOOL) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null", "boolean"); return; } *ob... |
1 | static int create_vorbis_context(vorbis_enc_context *venc, AVCodecContext *avccontext){ vorbis_enc_floor *fc; vorbis_enc_residue *rc; vorbis_enc_mapping *mc; int i, book, ret; venc->channels = avccontext->channels; venc->sample_rate = avccontext->sample_rate; venc->log2_blocksize[0] = venc->log2_blocksize[1] = 11; venc... |
1 | set_phy_ctrl(E1000State *s, int index, uint16_t val){ if ((val & MII_CR_AUTO_NEG_EN) && (val & MII_CR_RESTART_AUTO_NEG)) { qemu_get_queue(s->nic)->link_down = true; e1000_link_down(s); s->phy_reg[PHY_STATUS] &= ~MII_SR_AUTONEG_COMPLETE; DBGOUT(PHY, "Start link auto negotiation\n"); qemu_mod_timer(s->autoneg_timer, qemu... |
1 | PCIBus *i440fx_init(PCII440FXState **pi440fx_state, int *piix3_devfn, qemu_irq *pic){ DeviceState *dev; PCIBus *b; PCIDevice *d; I440FXState *s; PIIX3State *piix3; dev = qdev_create(NULL, "i440FX-pcihost"); s = FROM_SYSBUS(I440FXState, sysbus_from_qdev(dev)); b = pci_bus_new(&s->busdev.qdev, NULL, 0); s->bus = b; qdev_... |
1 | static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom){ int64_t start; int i, nb_chapters, str_len, version; char str[256+1]; if ((atom.size -= 5) < 0) return 0; version = avio_r8(pb); avio_rb24(pb); if (version) avio_rb32(pb); // ??? nb_chapters = avio_r8(pb); for (i = 0; i < nb_chapters; i++) { if (at... |
1 | static void do_wav_capture(Monitor *mon, const QDict *qdict){ const char *path = qdict_get_str(qdict, "path"); int has_freq = qdict_haskey(qdict, "freq"); int freq = qdict_get_try_int(qdict, "freq", -1); int has_bits = qdict_haskey(qdict, "bits"); int bits = qdict_get_try_int(qdict, "bits", -1); int has_channels = qdic... |
1 | static int old_codec47(SANMVideoContext *ctx, int top, int left, int width, int height){ int i, j, seq, compr, new_rot, tbl_pos, skip; int stride = ctx->pitch; uint8_t *dst = ((uint8_t*)ctx->frm0) + left + top * stride; uint8_t *prev1 = (uint8_t*)ctx->frm1; uint8_t *prev2 = (uint8_t*)ctx->frm2; uint32_t decoded_size; t... |
1 | static av_cold int vtenc_close(AVCodecContext *avctx){ VTEncContext *vtctx = avctx->priv_data; if(!vtctx->session) return 0; VTCompressionSessionInvalidate(vtctx->session); pthread_cond_destroy(&vtctx->cv_sample_sent); pthread_mutex_destroy(&vtctx->lock); CFRelease(vtctx->session); vtctx->session = NULL; return 0;} |
1 | static int mov_get_mpeg2_xdcam_codec_tag(AVFormatContext *s, MOVTrack *track){ int tag = track->par->codec_tag; int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE; AVStream *st = track->st; int rate = av_q2d(find_fps(s, st)); if (!tag) tag = MKTAG('m', '2', 'v', '1'); //fallback tag if (track->par->format ... |
1 | static int apply_color_indexing_transform(WebPContext *s){ ImageContext *img; ImageContext *pal; int i, x, y; uint8_t *p, *pi; img = &s->image[IMAGE_ROLE_ARGB]; pal = &s->image[IMAGE_ROLE_COLOR_INDEXING]; if (pal->size_reduction > 0) { GetBitContext gb_g; uint8_t *line; int pixel_bits = 8 >> pal->size_reduction; line =... |
1 | static void pnv_chip_power8e_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); PnvChipClass *k = PNV_CHIP_CLASS(klass); k->cpu_model = "POWER8E"; k->chip_type = PNV_CHIP_POWER8E; k->chip_cfam_id = 0x221ef04980000000ull; /* P8 Murano DD2.1 */ k->cores_mask = POWER8E_CORE_MASK; k->core_pi... |
1 | void uhci_port_test(struct qhc *hc, int port, uint16_t expect){ void *addr = hc->base + 0x10 + 2 * port; uint16_t value = qpci_io_readw(hc->dev, addr); uint16_t mask = ~(UHCI_PORT_WRITE_CLEAR | UHCI_PORT_RSVD1); g_assert((value & mask) == (expect & mask));} |
0 | GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp){ PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pslpi, ptr; DWORD length; GuestLogicalProcessorList *head, **link; Error *local_err = NULL; int64_t current; ptr = pslpi = NULL; length = 0; current = 0; head = NULL; link = &head; if ((GetLogicalProcessorInformation(psl... |
0 | static bool bdrv_drain_poll(BlockDriverState *bs){ bool waited = false; while (atomic_read(&bs->in_flight) > 0) { aio_poll(bdrv_get_aio_context(bs), true); waited = true; } return waited;} |
0 | static void cpu_exec_step(CPUState *cpu){ CPUClass *cc = CPU_GET_CLASS(cpu); TranslationBlock *tb; target_ulong cs_base, pc; uint32_t flags; uint32_t cflags = 1 | CF_IGNORE_ICOUNT; if (sigsetjmp(cpu->jmp_env, 0) == 0) { tb = tb_lookup__cpu_state(cpu, &pc, &cs_base, &flags, cflags & CF_HASH_MASK); if (tb == NULL) { mmap... |
0 | static bool intel_hda_xfer(HDACodecDevice *dev, uint32_t stnr, bool output, uint8_t *buf, uint32_t len){ HDACodecBus *bus = DO_UPCAST(HDACodecBus, qbus, dev->qdev.parent_bus); IntelHDAState *d = container_of(bus, IntelHDAState, codecs); target_phys_addr_t addr; uint32_t s, copy, left; IntelHDAStream *st; bool irq = fal... |
0 | int64_t qmp_guest_get_time(Error **errp){ int ret; qemu_timeval tq; int64_t time_ns; ret = qemu_gettimeofday(&tq); if (ret < 0) { error_setg_errno(errp, errno, "Failed to get time"); return -1; } time_ns = tq.tv_sec * 1000000000LL + tq.tv_usec * 1000; return time_ns;} |
0 | static int check_strtox_error(const char *nptr, char *ep, const char **endptr, int libc_errno){ if (libc_errno == 0 && ep == nptr) { libc_errno = EINVAL; } if (!endptr && *ep) { return -EINVAL; } if (endptr) { *endptr = ep; } return -libc_errno;} |
0 | static void ncq_cb(void *opaque, int ret){ NCQTransferState *ncq_tfs = (NCQTransferState *)opaque; IDEState *ide_state = &ncq_tfs->drive->port.ifs[0]; if (ret == -ECANCELED) { return; } /* Clear bit for this tag in SActive */ ncq_tfs->drive->port_regs.scr_act &= ~(1 << ncq_tfs->tag); if (ret < 0) { /* error */ ide_stat... |
0 | static bool aio_dispatch_handlers(AioContext *ctx){ AioHandler *node, *tmp; bool progress = false; /* * We have to walk very carefully in case aio_set_fd_handler is * called while we're walking. */ qemu_lockcnt_inc(&ctx->list_lock); QLIST_FOREACH_SAFE_RCU(node, &ctx->aio_handlers, node, tmp) { int revents; revents = no... |
0 | static void decode_opc_special3(CPUMIPSState *env, DisasContext *ctx){ int rs, rt, rd, sa; uint32_t op1, op2; rs = (ctx->opcode >> 21) & 0x1f; rt = (ctx->opcode >> 16) & 0x1f; rd = (ctx->opcode >> 11) & 0x1f; sa = (ctx->opcode >> 6) & 0x1f; op1 = MASK_SPECIAL3(ctx->opcode); switch (op1) { case OPC_EXT: case OPC_INS: ch... |
0 | static void scsi_dma_complete(void *opaque, int ret){ SCSIDiskReq *r = (SCSIDiskReq *)opaque; SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); bdrv_acct_done(s->qdev.conf.bs, &r->acct); if (ret) { if (scsi_handle_rw_error(r, -ret)) { goto done; } } r->sector += r->sector_count; r->sector_count = 0; scsi_r... |
0 | static void dump_sprs (CPUPPCState *env){ ppc_spr_t *spr; uint32_t pvr = env->spr[SPR_PVR]; uint32_t sr, sw, ur, uw; int i, j, n; printf("* SPRs for PVR=%08x\n", pvr); for (i = 0; i < 32; i++) { for (j = 0; j < 32; j++) { n = (i << 5) | j; spr = &env->spr_cb[n];#if !defined(CONFIG_USER_ONLY) sw = spr->oea_write != NULL... |
0 | void pc_cpus_init(PCMachineState *pcms){ int i; CPUClass *cc; ObjectClass *oc; const char *typename; gchar **model_pieces; X86CPU *cpu = NULL; MachineState *machine = MACHINE(pcms); /* init CPUs */ if (machine->cpu_model == NULL) {#ifdef TARGET_X86_64 machine->cpu_model = "qemu64";#else machine->cpu_model = "qemu32";#e... |
0 | static void destroy_all_mappings(void){ destroy_l2_mapping(&phys_map, P_L2_LEVELS - 1); phys_map_nodes_reset();} |
0 | static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb, const uint8_t *data_in, size_t data_in_len, uint8_t *data_out, size_t data_out_len, struct virtio_scsi_cmd_resp *resp_out){ QVirtQueue *vq; struct virtio_scsi_cmd_req req = { { 0 } }; struct virtio_scsi_cmd_resp resp = { .response = 0xff, .statu... |
0 | int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags){ int64_t target_sectors, ret, nb_sectors, sector_num = 0; int n; target_sectors = bdrv_nb_sectors(bs); if (target_sectors < 0) { return target_sectors; } for (;;) { nb_sectors = target_sectors - sector_num; if (nb_sectors <= 0) { return 0; } if (nb_sector... |
0 | raw_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int flags){ void *buf = NULL; BlockDriver *drv; QEMUIOVector local_qiov; int ret; if (bs->probed && sector_num == 0) { /* As long as these conditions are true, we can't get partial writes to * the probe buffer and can just... |
0 | void helper_stq_raw(uint64_t t0, uint64_t t1){ stq_raw(t1, t0);} |
0 | static void pc_machine_device_post_plug_cb(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { pc_dimm_post_plug(hotplug_dev, dev, errp); }} |
0 | static void create_gic(VirtBoardInfo *vbi, qemu_irq *pic, int type, bool secure){ /* We create a standalone GIC */ DeviceState *gicdev; SysBusDevice *gicbusdev; const char *gictype; int i; gictype = (type == 3) ? gicv3_class_name() : gic_class_name(); gicdev = qdev_create(NULL, gictype); qdev_prop_set_uint32(gicdev, "r... |
0 | static void pci_change_irq_level(PCIDevice *pci_dev, int irq_num, int change){ PCIBus *bus; for (;;) { bus = pci_dev->bus; irq_num = bus->map_irq(pci_dev, irq_num); if (bus->set_irq) break; pci_dev = bus->parent_dev; } bus->irq_count[irq_num] += change; bus->set_irq(bus->irq_opaque, irq_num, bus->irq_count[irq_num] != ... |
0 | static void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend){ const char *logfile = qemu_opt_get(opts, "logfile"); backend->has_logfile = logfile != NULL; backend->logfile = logfile ? g_strdup(logfile) : NULL; backend->has_logappend = true; backend->logappend = qemu_opt_get_bool(opts, "logappend", false);} |
0 | static inline int vmsvga_fifo_length(struct vmsvga_state_s *s){ int num; if (!s->config || !s->enable) return 0; num = CMD(next_cmd) - CMD(stop); if (num < 0) num += CMD(max) - CMD(min); return num >> 2;} |
0 | PageCache *cache_init(size_t num_pages, size_t page_size){ int64_t i; PageCache *cache; if (num_pages <= 0) { DPRINTF("invalid number of pages\n"); return NULL; } /* We prefer not to abort if there is no memory */ cache = g_try_malloc(sizeof(*cache)); if (!cache) { DPRINTF("Failed to allocate cache\n"); return NULL; } ... |
0 | void pit_set_gate(PITState *pit, int channel, int val){ PITChannelState *s = &pit->channels[channel]; switch(s->mode) { default: case 0: case 4: /* XXX: just disable/enable counting */ break; case 1: case 5: if (s->gate < val) { /* restart counting on rising edge */ s->count_load_time = qemu_get_clock(vm_clock); pit_ir... |
0 | static int xhci_ep_nuke_one_xfer(XHCITransfer *t, TRBCCode report){ int killed = 0; if (report && (t->running_async || t->running_retry)) { t->status = report; xhci_xfer_report(t); } if (t->running_async) { usb_cancel_packet(&t->packet); t->running_async = 0; killed = 1; } if (t->running_retry) { XHCIEPContext *epctx =... |
0 | static int kvm_mce_in_progress(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) { fprintf(stderr, "Failed to get MCE status\n"); return 0; } return !!(msr_mcg_status.data & MCG_STATUS_MCIP);} |
0 | static int encode_picture(MpegEncContext *s, int picture_number){ int i; int bits; s->picture_number = picture_number; /* Reset the average MB variance */ s->me.mb_var_sum_temp = s->me.mc_mb_var_sum_temp = 0; /* we need to initialize some time vars before we can encode b-frames */ // RAL: Condition added for MPEG1VIDEO... |
0 | static void stellaris_enet_cleanup(NetClientState *nc){ stellaris_enet_state *s = qemu_get_nic_opaque(nc); s->nic = NULL;} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.