label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | bool block_job_is_paused(BlockJob *job){ return job->paused;} |
0 | int qemu_register_machine(QEMUMachine *m){ char *name = g_strconcat(m->name, TYPE_MACHINE_SUFFIX, NULL); TypeInfo ti = { .name = name, .parent = TYPE_MACHINE, .class_init = machine_class_init, .class_data = (void *)m, }; type_register(&ti); g_free(name); return 0;} |
0 | static int tosa_dac_event(I2CSlave *i2c, enum i2c_event event){ TosaDACState *s = TOSA_DAC(i2c); s->len = 0; switch (event) { case I2C_START_SEND: break; case I2C_START_RECV: printf("%s: recv not supported!!!\n", __FUNCTION__); break; case I2C_FINISH:#ifdef VERBOSE if (s->len < 2) printf("%s: message too short (%i byte... |
0 | av_cold void ff_vp8dsp_init_neon(VP8DSPContext *dsp){ dsp->vp8_luma_dc_wht = ff_vp8_luma_dc_wht_neon; dsp->vp8_idct_add = ff_vp8_idct_add_neon; dsp->vp8_idct_dc_add = ff_vp8_idct_dc_add_neon; dsp->vp8_idct_dc_add4y = ff_vp8_idct_dc_add4y_neon; dsp->vp8_idct_dc_add4uv = ff_vp8_idct_dc_add4uv_neon; dsp->vp8_v_loop_filter... |
0 | static int qemu_rdma_block_for_wrid(RDMAContext *rdma, int wrid_requested, uint32_t *byte_len){ int num_cq_events = 0, ret = 0; struct ibv_cq *cq; void *cq_ctx; uint64_t wr_id = RDMA_WRID_NONE, wr_id_in; if (ibv_req_notify_cq(rdma->cq, 0)) { return -1; } /* poll cq first */ while (wr_id != wrid_requested) { ret = qemu_... |
0 | static void mmio_ide_cmd_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size){ MMIOState *s = opaque; ide_cmd_write(&s->bus, 0, val);} |
0 | static void xenfb_copy_mfns(int mode, int count, unsigned long *dst, void *src){ uint32_t *src32 = src; uint64_t *src64 = src; int i; for (i = 0; i < count; i++)dst[i] = (mode == 32) ? src32[i] : src64[i];} |
0 | void memory_region_unregister_iommu_notifier(MemoryRegion *mr, Notifier *n){ notifier_remove(n); if (mr->iommu_ops->notify_stopped && QLIST_EMPTY(&mr->iommu_notify.notifiers)) { mr->iommu_ops->notify_stopped(mr); }} |
0 | int inet_connect(const char *str, bool block, Error **errp){ QemuOpts *opts; int sock = -1; opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL); if (inet_parse(opts, str) == 0) { if (block) { qemu_opt_set(opts, "block", "on"); } sock = inet_connect_opts(opts, errp); } else { error_set(errp, QERR_SOCKET_CREATE_FAILED); ... |
0 | static void eth_send(mv88w8618_eth_state *s, int queue_index){ uint32_t desc_addr = s->tx_queue[queue_index]; mv88w8618_tx_desc desc; uint8_t buf[2048]; int len; do { eth_tx_desc_get(desc_addr, &desc); if (desc.cmdstat & MP_ETH_TX_OWN) { len = desc.bytes; if (len < 2048) { cpu_physical_memory_read(desc.buffer, buf, len... |
0 | static void test_submit_aio(void){ WorkerTestData data = { .n = 0, .ret = -EINPROGRESS }; data.aiocb = thread_pool_submit_aio(worker_cb, &data, done_cb, &data); /* The callbacks are not called until after the first wait. */ active = 1; g_assert_cmpint(data.ret, ==, -EINPROGRESS); qemu_aio_flush(); g_assert_cmpint(activ... |
0 | static int hls_start(AVFormatContext *s){ HLSContext *c = s->priv_data; AVFormatContext *oc = c->avf; int err = 0; if (c->wrap) c->number %= c->wrap; if (av_get_frame_filename(oc->filename, sizeof(oc->filename), c->basename, c->number++) < 0) return AVERROR(EINVAL); if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLA... |
0 | void migrate_decompress_threads_create(void){ int i, thread_count; thread_count = migrate_decompress_threads(); decompress_threads = g_new0(QemuThread, thread_count); decomp_param = g_new0(DecompressParam, thread_count); quit_decomp_thread = false; qemu_mutex_init(&decomp_done_lock); qemu_cond_init(&decomp_done_cond); ... |
0 | void qdev_prop_set_drive(DeviceState *dev, const char *name, DriveInfo *value){ qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE);} |
0 | static void ppc_spapr_reset(void){ sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); PowerPCCPU *first_ppc_cpu; uint32_t rtas_limit; /* Check for unknown sysbus devices */ foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL); /* Reset the hash table & recalc the RMA */ spapr_reset_htab(spapr); qe... |
0 | static void create_one_flash(const char *name, hwaddr flashbase, hwaddr flashsize){ /* Create and map a single flash device. We use the same * parameters as the flash devices on the Versatile Express board. */ DriveInfo *dinfo = drive_get_next(IF_PFLASH); DeviceState *dev = qdev_create(NULL, "cfi.pflash01"); const uint... |
0 | gdb_handlesig (CPUState *env, int sig){ GDBState *s; char buf[256]; int n; s = &gdbserver_state; if (gdbserver_fd < 0 || s->fd < 0) return sig; /* disable single step if it was enabled */ cpu_single_step(env, 0); tb_flush(env); if (sig != 0) { snprintf(buf, sizeof(buf), "S%02x", sig); put_packet(s, buf); } /* put_packe... |
0 | uint32_t HELPER(csst)(CPUS390XState *env, uint32_t r3, uint64_t a1, uint64_t a2){#if !defined(CONFIG_USER_ONLY) || defined(CONFIG_ATOMIC128) uint32_t mem_idx = cpu_mmu_index(env, false);#endif uintptr_t ra = GETPC(); uint32_t fc = extract32(env->regs[0], 0, 8); uint32_t sc = extract32(env->regs[0], 8, 8); uint64_t pl =... |
0 | static void nbd_request_put(NBDRequest *req){ NBDClient *client = req->client; if (req->data) { qemu_vfree(req->data); } g_slice_free(NBDRequest, req); if (client->nb_requests-- == MAX_NBD_REQUESTS) { qemu_notify_event(); } nbd_client_put(client);} |
0 | void timerlistgroup_deinit(QEMUTimerListGroup *tlg){ QEMUClockType type; for (type = 0; type < QEMU_CLOCK_MAX; type++) { timerlist_free(tlg->tl[type]); }} |
0 | static int nbd_receive_options(NBDClient *client){ int csock = client->sock; uint32_t flags; /* Client sends: [ 0 .. 3] client flags [ 0 .. 7] NBD_OPTS_MAGIC [ 8 .. 11] NBD option [12 .. 15] Data length ... Rest of request [ 0 .. 7] NBD_OPTS_MAGIC [ 8 .. 11] Second NBD option [12 .. 15] Data length ... Rest of request ... |
0 | void xtensa_breakpoint_handler(CPUState *cs){ XtensaCPU *cpu = XTENSA_CPU(cs); CPUXtensaState *env = &cpu->env; if (cs->watchpoint_hit) { if (cs->watchpoint_hit->flags & BP_CPU) { uint32_t cause; cs->watchpoint_hit = NULL; cause = check_hw_breakpoints(env); if (cause) { debug_exception_env(env, cause); } cpu_resume_fro... |
0 | static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename){ const QCowHeader *cow_header = (const void *)buf; if (buf_size >= sizeof(QCowHeader) && be32_to_cpu(cow_header->magic) == QCOW_MAGIC && be32_to_cpu(cow_header->version) >= QCOW_VERSION) return 100; else return 0;} |
0 | static int read_header(AVFormatContext *s, AVFormatParameters *ap){ BinkDemuxContext *bink = s->priv_data; AVIOContext *pb = s->pb; uint32_t fps_num, fps_den; AVStream *vst, *ast; unsigned int i; uint32_t pos, next_pos; uint16_t flags; int keyframe; vst = av_new_stream(s, 0); if (!vst) return AVERROR(ENOMEM); vst->code... |
0 | static int ftp_status(FTPContext *s, char **line, const int response_codes[]){ int err, i, result = 0, pref_code_found = 0, wait_count = 100; char buf[CONTROL_BUFFER_SIZE]; /* Set blocking mode */ s->conn_control_block_flag = 0; for (;;) { if ((err = ftp_get_line(s, buf, sizeof(buf))) < 0) { if (err == AVERROR_EXIT) { ... |
0 | static void unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb){ int i, j, k; int coding_mode; int motion_x[6]; int motion_y[6]; int last_motion_x = 0; int last_motion_y = 0; int prior_last_motion_x = 0; int prior_last_motion_y = 0; int current_macroblock; int current_fragment; debug_vp3(" vp3: unpacking motion vect... |
0 | static void ipvideo_decode_opcodes(IpvideoContext *s, AVFrame *frame){ int x, y; unsigned char opcode; int ret; GetBitContext gb; bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */ if (!s->is_16bpp) { /* this is PAL8, so make the palette available */ memcpy(frame->data[1], s->pal, AVPALETTE_SIZE); s->s... |
0 | static int cinvideo_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; CinVideoContext *cin = avctx->priv_data; int i, y, palette_type, palette_colors_count, bitmap_frame_type, bitmap_frame_size, res = 0; palette_type = buf[0];... |
0 | static void check_threshold_8(void){ LOCAL_ALIGNED_32(uint8_t, in , [WIDTH_PADDED]); LOCAL_ALIGNED_32(uint8_t, threshold, [WIDTH_PADDED]); LOCAL_ALIGNED_32(uint8_t, min , [WIDTH_PADDED]); LOCAL_ALIGNED_32(uint8_t, max , [WIDTH_PADDED]); LOCAL_ALIGNED_32(uint8_t, out_ref , [WIDTH_PADDED]); LOCAL_ALIGNED_32(uint8_t, out_... |
1 | static void gen_rp_realize(DeviceState *dev, Error **errp){ PCIDevice *d = PCI_DEVICE(dev); GenPCIERootPort *grp = GEN_PCIE_ROOT_PORT(d); PCIERootPortClass *rpc = PCIE_ROOT_PORT_GET_CLASS(d); rpc->parent_realize(dev, errp); int rc = pci_bridge_qemu_reserve_cap_init(d, 0, grp->bus_reserve, grp->io_reserve, grp->mem_rese... |
1 | static bool megasas_use_msi(MegasasState *s){ return s->msi != ON_OFF_AUTO_OFF;} |
1 | int32_t scsi_send_command(SCSIDevice *s, uint32_t tag, uint8_t *buf, int lun){ int64_t nb_sectors; uint32_t lba; uint32_t len; int cmdlen; int is_write; s->command = buf[0]; s->tag = tag; s->sector_count = 0; s->buf_pos = 0; s->buf_len = 0; is_write = 0; DPRINTF("Command: 0x%02x", buf[0]); switch (s->command >> 5) { ca... |
1 | static int vda_h264_uninit(AVCodecContext *avctx){ VDAContext *vda = avctx->internal->hwaccel_priv_data; av_freep(&vda->bitstream); if (vda->frame) CVPixelBufferRelease(vda->frame); return 0;} |
1 | static void usb_mtp_handle_data(USBDevice *dev, USBPacket *p){ MTPState *s = USB_MTP(dev); MTPControl cmd; mtp_container container; uint32_t params[5]; int i, rc; switch (p->ep->nr) { case EP_DATA_IN: if (s->data_out != NULL) { /* guest bug */ trace_usb_mtp_stall(s->dev.addr, "awaiting data-out"); p->status = USB_RET_S... |
1 | ReadLineState *readline_init(ReadLinePrintfFunc *printf_func, ReadLineFlushFunc *flush_func, void *opaque, ReadLineCompletionFunc *completion_finder){ ReadLineState *rs = g_malloc0(sizeof(*rs)); rs->hist_entry = -1; rs->opaque = opaque; rs->printf_func = printf_func; rs->flush_func = flush_func; rs->completion_finder =... |
1 | static int ahci_populate_sglist(AHCIDevice *ad, QEMUSGList *sglist, int32_t offset){ AHCICmdHdr *cmd = ad->cur_cmd; uint16_t opts = le16_to_cpu(cmd->opts); uint16_t prdtl = le16_to_cpu(cmd->prdtl); uint64_t cfis_addr = le64_to_cpu(cmd->tbl_addr); uint64_t prdt_addr = cfis_addr + 0x80; dma_addr_t prdt_len = (prdtl * siz... |
1 | 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]", NULL); g_assert(embedded_obj != NULL); obj ... |
1 | static ram_addr_t ram_block_add(RAMBlock *new_block, Error **errp){ RAMBlock *block; RAMBlock *last_block = NULL; ram_addr_t old_ram_size, new_ram_size; old_ram_size = last_ram_offset() >> TARGET_PAGE_BITS; qemu_mutex_lock_ramlist(); new_block->offset = find_ram_offset(new_block->max_length); if (!new_block->host) { if... |
1 | void qemu_set_log(int log_flags, bool use_own_buffers){ qemu_loglevel = log_flags; if (qemu_loglevel && !qemu_logfile) { qemu_logfile = fopen(logfilename, log_append ? "a" : "w"); if (!qemu_logfile) { perror(logfilename); _exit(1); } /* must avoid mmap() usage of glibc by setting a buffer "by hand" */ if (use_own_buffe... |
1 | static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom){ const uint32_t ddts_size = 20; AVStream *st = NULL; uint8_t *buf = NULL; uint32_t frame_duration_code = 0; uint32_t channel_layout_code = 0; GetBitContext gb; buf = av_malloc(ddts_size + AV_INPUT_BUFFER_PADDING_SIZE); if (!buf) { return AVERROR(ENO... |
1 | void OPPROTO op_check_subfo_64 (void){ if (likely(!(((uint64_t)(~T2) ^ (uint64_t)T1 ^ UINT64_MAX) & ((uint64_t)(~T2) ^ (uint64_t)T0) & (1ULL << 63)))) { xer_ov = 0; } else { xer_ov = 1; xer_so = 1; } RETURN();} |
1 | void pci_data_write(PCIBus *s, uint32_t addr, uint32_t val, int len){ PCIDevice *pci_dev = pci_dev_find_by_addr(s, addr); uint32_t config_addr = addr & (PCI_CONFIG_SPACE_SIZE - 1); if (!pci_dev) return; PCI_DPRINTF("%s: %s: addr=%02" PRIx32 " val=%08" PRIx32 " len=%d\n", __func__, pci_dev->name, config_addr, val, len);... |
0 | static int mkv_write_tags(AVFormatContext *s){ ebml_master tags = {0}; int i, ret; ff_metadata_conv_ctx(s, ff_mkv_metadata_conv, NULL); if (av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX)) { ret = mkv_write_tag(s, s->metadata, 0, 0, &tags); if (ret < 0) return ret; } for (i = 0; i < s->nb_streams; i++) { AVSt... |
1 | static av_always_inline void mc_chroma_dir(VP9Context *s, vp9_mc_func(*mc)[2], uint8_t *dst_u, uint8_t *dst_v, ptrdiff_t dst_stride, const uint8_t *ref_u, ptrdiff_t src_stride_u, const uint8_t *ref_v, ptrdiff_t src_stride_v, ThreadFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP56mv *mv, int bw, int bh, int w, int ... |
1 | void qmp_drive_mirror(DriveMirror *arg, Error **errp){ BlockDriverState *bs; BlockDriverState *source, *target_bs; AioContext *aio_context; BlockMirrorBackingMode backing_mode; Error *local_err = NULL; QDict *options = NULL; int flags; int64_t size; const char *format = arg->format; bs = qmp_get_root_bs(arg->device, er... |
1 | void ff_thread_report_progress(ThreadFrame *f, int n, int field){ PerThreadContext *p; atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL; if (!progress || atomic_load_explicit(&progress[field], memory_order_relaxed) >= n) return; p = f->owner[field]->internal->thread_ctx; if (f->owner[field]->d... |
1 | static inline int64_t bs_get_v(const uint8_t **bs){ int64_t v = 0; int br = 0; int c; do { c = **bs; (*bs)++; v <<= 7; v |= c & 0x7F; br++; if (br > 10) return -1; } while (c & 0x80); return v - br;} |
1 | static int nbd_receive_request(int csock, struct nbd_request *request){ uint8_t buf[4 + 4 + 8 + 8 + 4]; uint32_t magic; if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) { LOG("read failed"); errno = EINVAL; return -1; } /* Request [ 0 .. 3] magic (NBD_REQUEST_MAGIC) [ 4 .. 7] type (0 == READ, 1 == WRITE) [ 8 .. 1... |
1 | static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size){ VP56RangeCoder *c = &s->c; int parse_filter_info = 0; int coeff_offset = 0; int vrt_shift = 0; int sub_version; int rows, cols; int res = 0; int ret; int separated_coeff = buf[0] & 1; s->frames[VP56_FRAME_CURRENT]->key_frame = !(buf[0] & 0x8... |
1 | static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){ int i, j, k, m; double l2tab[256]; for (i = 1; i < 256; i++) l2tab[i] = log2(i / 256.0); for (i = 0; i < 256; i++) { double best_len[256]; double p = i / 256.0; for (j = 0; j < 256; j++) best_len[j] = 1 << 30; for (j = FFMAX(i - 10... |
1 | static ExitStatus gen_bcond(DisasContext *ctx, TCGCond cond, int ra, int32_t disp, int mask){ TCGv cmp_tmp; if (mask) { cmp_tmp = tcg_temp_new(); tcg_gen_andi_i64(cmp_tmp, load_gpr(ctx, ra), 1); } else { cmp_tmp = load_gpr(ctx, ra); } return gen_bcond_internal(ctx, cond, cmp_tmp, disp);} |
1 | static void tcg_out_qemu_st (TCGContext *s, const TCGArg *args, int opc){ int addr_reg, r0, r1, data_reg, data_reg2, bswap, rbase;#ifdef CONFIG_SOFTMMU int mem_index, r2, addr_reg2; uint8_t *label_ptr;#endif data_reg = *args++; if (opc == 3) data_reg2 = *args++; else data_reg2 = 0; addr_reg = *args++;#ifdef CONFIG_SOFT... |
1 | int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque, int abort_on_failure){ QemuOpts *opts; int rc = 0; QTAILQ_FOREACH(opts, &list->head, next) { rc = func(opts, opaque); if (abort_on_failure && rc != 0) break; } return rc;} |
1 | static void gen_tlbsx_booke206(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else TCGv t0; if (unlikely(!ctx->mem_idx)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } if (rA(ctx->opcode)) { t0 = tcg_temp_new(); tcg_gen_mov_tl(t0, cpu_gpr[rD(ctx->opcode)]... |
1 | static inline int parse_nal_units(AVCodecParserContext *s, const uint8_t *buf, int buf_size, AVCodecContext *avctx){ HEVCParserContext *ctx = s->priv_data; HEVCContext *h = &ctx->h; GetBitContext *gb; SliceHeader *sh = &h->sh; HEVCParamSets *ps = &h->ps; H2645Packet *pkt = &ctx->pkt; const uint8_t *buf_end = buf + buf_... |
1 | static int afx_init1(SysBusDevice *dev){ AFXState *s = TCX_AFX(dev); memory_region_init_ram(&s->mem, OBJECT(s), "sun4m.afx", 4, &error_abort); vmstate_register_ram_global(&s->mem); sysbus_init_mmio(dev, &s->mem); return 0;} |
0 | static float ssim_end4(int sum0[5][4], int sum1[5][4], int width){ float ssim = 0.0; int i; for (i = 0; i < width; i++) ssim += ssim_end1(sum0[i][0] + sum0[i + 1][0] + sum1[i][0] + sum1[i + 1][0], sum0[i][1] + sum0[i + 1][1] + sum1[i][1] + sum1[i + 1][1], sum0[i][2] + sum0[i + 1][2] + sum1[i][2] + sum1[i + 1][2], sum0[... |
0 | static void avc_loopfilter_luma_intra_edge_hor_msa(uint8_t *data, uint8_t alpha_in, uint8_t beta_in, uint32_t img_width){ v16u8 p2_asub_p0, q2_asub_q0, p0_asub_q0; v16u8 alpha, beta; v16u8 is_less_than, is_less_than_beta, negate_is_less_than_beta; v16u8 p2, p1, p0, q0, q1, q2; v16u8 p3_org, p2_org, p1_org, p0_org, q0_o... |
0 | struct omap_mpu_state_s *omap2420_mpu_init(MemoryRegion *sysmem, unsigned long sdram_size, const char *core){ struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) g_malloc0(sizeof(struct omap_mpu_state_s)); qemu_irq dma_irqs[4]; DriveInfo *dinfo; int i; SysBusDevice *busdev; struct omap_target_agent_s *ta; /* Core ... |
0 | static void vfio_unmap_bars(VFIOPCIDevice *vdev){ int i; for (i = 0; i < PCI_ROM_SLOT; i++) { vfio_unmap_bar(vdev, i); } if (vdev->has_vga) { vfio_vga_quirk_teardown(vdev); pci_unregister_vga(&vdev->pdev); }} |
0 | static void pcibus_dev_print(Monitor *mon, DeviceState *dev, int indent){ PCIDevice *d = (PCIDevice *)dev; const pci_class_desc *desc; char ctxt[64]; PCIIORegion *r; int i, class; class = pci_get_word(d->config + PCI_CLASS_DEVICE); desc = pci_class_descriptions; while (desc->desc && class != desc->class) desc++; if (de... |
0 | ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class, const char *typename, const char *file, int line, const char *func){ ObjectClass *ret; trace_object_class_dynamic_cast_assert(class ? class->type->name : "(null)", typename, file, line, func);#ifdef CONFIG_QOM_CAST_DEBUG int i; for (i = 0; i < OBJECT_CLA... |
0 | static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback){#define HWACCEL_MAX (CONFIG_H264_DXVA2_HWACCEL + \ CONFIG_H264_D3D11VA_HWACCEL + \ CONFIG_H264_VAAPI_HWACCEL + \ (CONFIG_H264_VDA_HWACCEL * 2) + \ CONFIG_H264_VIDEOTOOLBOX_HWACCEL + \ CONFIG_H264_VDPAU_HWACCEL) enum AVPixelFormat pix_fmts[HW... |
0 | void msix_load(PCIDevice *dev, QEMUFile *f){ unsigned n = dev->msix_entries_nr; unsigned int vector; if (!(dev->cap_present & QEMU_PCI_CAP_MSIX)) { return; } msix_free_irq_entries(dev); qemu_get_buffer(f, dev->msix_table_page, n * PCI_MSIX_ENTRY_SIZE); qemu_get_buffer(f, dev->msix_table_page + MSIX_PAGE_PENDING, (n + 7... |
0 | static void vga_update_display(void *opaque){ VGACommonState *s = opaque; int full_update, graphic_mode; qemu_flush_coalesced_mmio_buffer(); if (ds_get_bits_per_pixel(s->ds) == 0) { /* nothing to do */ } else { full_update = 0; if (!(s->ar_index & 0x20) && /* extra CGA compatibility hacks (not in standard VGA */ (!(vga... |
0 | static bool eckd_valid_address(BootMapPointer *p){ const uint64_t cylinder = p->eckd.cylinder + ((p->eckd.head & 0xfff0) << 12); const uint64_t head = p->eckd.head & 0x000f; if (head >= virtio_get_heads() || p->eckd.sector > virtio_get_sectors() || p->eckd.sector <= 0) { return false; } if (!virtio_guessed_disk_nature(... |
0 | static void test_bh_delete_from_cb(void){ BHTestData data1 = { .n = 0, .max = 1 }; data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1); qemu_bh_schedule(data1.bh); g_assert_cmpint(data1.n, ==, 0); wait_for_aio(); g_assert_cmpint(data1.n, ==, data1.max); g_assert(data1.bh == NULL); g_assert(!aio_poll(ctx, false));} |
0 | static void v9fs_create(void *opaque){ int32_t fid; int err = 0; size_t offset = 7; V9fsFidState *fidp; V9fsQID qid; int32_t perm; int8_t mode; V9fsPath path; struct stat stbuf; V9fsString name; V9fsString extension; int iounit; V9fsPDU *pdu = opaque; v9fs_path_init(&path); pdu_unmarshal(pdu, offset, "dsdbs", &fid, &na... |
0 | static void dma_bdrv_cb(void *opaque, int ret){ DMAAIOCB *dbs = (DMAAIOCB *)opaque; dma_addr_t cur_addr, cur_len; void *mem; trace_dma_bdrv_cb(dbs, ret); dbs->acb = NULL; dbs->sector_num += dbs->iov.size / 512; if (dbs->sg_cur_index == dbs->sg->nsg || ret < 0) { dma_complete(dbs, ret); return; } dma_bdrv_unmap(dbs); wh... |
0 | static void vtd_root_table_setup(IntelIOMMUState *s){ s->root = vtd_get_quad_raw(s, DMAR_RTADDR_REG); s->root_extended = s->root & VTD_RTADDR_RTT; s->root &= VTD_RTADDR_ADDR_MASK(VTD_HOST_ADDRESS_WIDTH); trace_vtd_reg_dmar_root(s->root, s->root_extended);} |
0 | CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, void (*init)(struct CharDriverState *s), Error **errp){ Error *local_err = NULL; CharDriver *cd; CharDriverState *chr; GSList *i; ChardevReturn *ret = NULL; ChardevBackend *backend; const char *id = qemu_opts_id(opts); char *bid = NULL; if (id == NULL) { error_set... |
0 | void hmp_cont(Monitor *mon, const QDict *qdict){ Error *errp = NULL; qmp_cont(&errp); if (error_is_set(&errp)) { if (error_is_type(errp, QERR_DEVICE_ENCRYPTED)) { const char *device; /* The device is encrypted. Ask the user for the password and retry */ device = error_get_field(errp, "device"); assert(device != NULL); ... |
0 | static int smka_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ SmackerAudioContext *s = avctx->priv_data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; GetBitContext gb; HuffContext h[4] = { { 0 } }; VLC vlc[4] = { { 0 } }; int16_t *samples; uint8_t *samples8; int ... |
0 | CharDriverState *qemu_chr_open(const char *filename){ const char *p; if (!strcmp(filename, "vc")) { return text_console_init(&display_state); } else if (!strcmp(filename, "null")) { return qemu_chr_open_null(); } else if (strstart(filename, "tcp:", &p)) { return qemu_chr_open_tcp(p, 0, 0); } else if (strstart(filename,... |
0 | void spapr_events_init(sPAPREnvironment *spapr){ spapr->epow_irq = xics_alloc(spapr->icp, 0, 0, false); spapr->epow_notifier.notify = spapr_powerdown_req; qemu_register_powerdown_notifier(&spapr->epow_notifier); spapr_rtas_register(RTAS_CHECK_EXCEPTION, "check-exception", check_exception);} |
0 | GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64, bool has_count, int64_t count, Error **errp){ GuestFileWrite *write_data = NULL; guchar *buf; gsize buf_len; bool is_ok; DWORD write_count; GuestFileHandle *gfh = guest_file_handle_find(handle, errp); HANDLE fh; if (!gfh) { return NULL; } fh = gf... |
0 | static int nbd_config(BDRVNBDState *s, QDict *options, char **export){ Error *local_err = NULL; if (qdict_haskey(options, "path") == qdict_haskey(options, "host")) { if (qdict_haskey(options, "path")) { qerror_report(ERROR_CLASS_GENERIC_ERROR, "path and host may not " "be used at the same time."); } else { qerror_repor... |
0 | int qemu_loadvm_state(QEMUFile *f){ LIST_HEAD(, LoadStateEntry) loadvm_handlers = LIST_HEAD_INITIALIZER(loadvm_handlers); LoadStateEntry *le, *new_le; uint8_t section_type; unsigned int v; int ret; v = qemu_get_be32(f); if (v != QEMU_VM_FILE_MAGIC) return -EINVAL; v = qemu_get_be32(f); if (v == QEMU_VM_FILE_VERSION_COM... |
0 | int cpu_breakpoint_remove(CPUState *cpu, vaddr pc, int flags){#if defined(TARGET_HAS_ICE) CPUBreakpoint *bp; QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) { if (bp->pc == pc && bp->flags == flags) { cpu_breakpoint_remove_by_ref(cpu, bp); return 0; } } return -ENOENT;#else return -ENOSYS;#endif} |
0 | void kvm_s390_interrupt(S390CPU *cpu, int type, uint32_t code){ kvm_s390_interrupt_internal(cpu, type, code, 0, 0);} |
0 | static int device_init(AVFormatContext *ctx, int *width, int *height, uint32_t pix_fmt){ struct video_data *s = ctx->priv_data; int fd = s->fd; struct v4l2_format fmt; struct v4l2_pix_format *pix = &fmt.fmt.pix; int res; memset(&fmt, 0, sizeof(struct v4l2_format)); fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; pix->width = *... |
0 | static void arm1026_initfn(Object *obj){ ARMCPU *cpu = ARM_CPU(obj); cpu->dtb_compatible = "arm,arm1026"; set_feature(&cpu->env, ARM_FEATURE_V5); set_feature(&cpu->env, ARM_FEATURE_VFP); set_feature(&cpu->env, ARM_FEATURE_AUXCR); set_feature(&cpu->env, ARM_FEATURE_DUMMY_C15_REGS); set_feature(&cpu->env, ARM_FEATURE_CAC... |
0 | void msi_uninit(struct PCIDevice *dev){ uint16_t flags; uint8_t cap_size; if (!(dev->cap_present & QEMU_PCI_CAP_MSI)) { return; } flags = pci_get_word(dev->config + msi_flags_off(dev)); cap_size = msi_cap_sizeof(flags); pci_del_capability(dev, PCI_CAP_ID_MSI, cap_size); dev->cap_present &= ~QEMU_PCI_CAP_MSI; MSI_DEV_PR... |
0 | static uint64_t mv88w8618_pic_read(void *opaque, target_phys_addr_t offset, unsigned size){ mv88w8618_pic_state *s = opaque; switch (offset) { case MP_PIC_STATUS: return s->level & s->enabled; default: return 0; }} |
0 | static int nic_can_receive(void *opaque){ dp8393xState *s = opaque; if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN)) return 0; if (s->regs[SONIC_ISR] & SONIC_ISR_RBE) return 0; return 1;} |
0 | void sm501_init(MemoryRegion *address_space_mem, uint32_t base, uint32_t local_mem_bytes, qemu_irq irq, CharDriverState *chr){ SM501State * s; DeviceState *dev; MemoryRegion *sm501_system_config = g_new(MemoryRegion, 1); MemoryRegion *sm501_disp_ctrl = g_new(MemoryRegion, 1); MemoryRegion *sm501_2d_engine = g_new(Memor... |
0 | static void pc_cpu_unplug_request_cb(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ int idx = -1; HotplugHandlerClass *hhc; Error *local_err = NULL; PCMachineState *pcms = PC_MACHINE(hotplug_dev); pc_find_cpu_slot(pcms, CPU(dev), &idx); assert(idx != -1); if (idx == 0) { error_setg(&local_err, "Boot CPU ... |
0 | static int smc91c111_can_receive(void *opaque){ smc91c111_state *s = (smc91c111_state *)opaque; if ((s->rcr & RCR_RXEN) == 0 || (s->rcr & RCR_SOFT_RST)) return 1; if (s->allocated == (1 << NUM_PACKETS) - 1) return 0; return 1;} |
0 | static void sigchld_bh_handler(void *opaque){ ChildProcessRecord *rec, *next; QLIST_FOREACH_SAFE(rec, &child_watches, next, next) { if (waitpid(rec->pid, NULL, WNOHANG) == rec->pid) { QLIST_REMOVE(rec, next); g_free(rec); } }} |
0 | static PCIIDEState *pci_from_bm(BMDMAState *bm){ return bm->pci_dev;} |
0 | static int local_set_mapped_file_attrat(int dirfd, const char *name, FsCred *credp){ FILE *fp; int ret; char buf[ATTR_MAX]; int uid = -1, gid = -1, mode = -1, rdev = -1; int map_dirfd; ret = mkdirat(dirfd, VIRTFS_META_DIR, 0700); if (ret < 0 && errno != EEXIST) { return -1; } map_dirfd = openat_dir(dirfd, VIRTFS_META_D... |
0 | static void check_ieee_exceptions(CPUSPARCState *env){ target_ulong status; status = get_float_exception_flags(&env->fp_status); if (status) { /* Copy IEEE 754 flags into FSR */ if (status & float_flag_invalid) { env->fsr |= FSR_NVC; } if (status & float_flag_overflow) { env->fsr |= FSR_OFC; } if (status & float_flag_u... |
0 | static hwaddr ppc_hash64_htab_lookup(PowerPCCPU *cpu, ppc_slb_t *slb, target_ulong eaddr, ppc_hash_pte64_t *pte, unsigned *pshift){ CPUPPCState *env = &cpu->env; hwaddr hash, ptex; uint64_t vsid, epnmask, epn, ptem; const struct ppc_one_seg_page_size *sps = slb->sps; /* The SLB store path should prevent any bad page si... |
0 | QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exists, Error **errp){ QemuOpts *opts = NULL; if (id) { if (!id_wellformed(id)) { error_set(errp,QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");#if 0 /* conversion from qerror_report() to error_set() broke this: */ error_printf_unless_qmp(... |
0 | static int coroutine_fn backup_run_incremental(BackupBlockJob *job){ bool error_is_read; int ret = 0; int clusters_per_iter; uint32_t granularity; int64_t sector; int64_t cluster; int64_t end; int64_t last_cluster = -1; int64_t sectors_per_cluster = cluster_size_sectors(job); BdrvDirtyBitmapIter *dbi; granularity = bdr... |
0 | static uint64_t omap_eac_read(void *opaque, target_phys_addr_t addr, unsigned size){ struct omap_eac_s *s = (struct omap_eac_s *) opaque; uint32_t ret; if (size != 2) { return omap_badwidth_read16(opaque, addr); } switch (addr) { case 0x000:/* CPCFR1 */ return s->config[0]; case 0x004:/* CPCFR2 */ return s->config[1]; ... |
1 | static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno){ int compno, reslevelno, ret; Jpeg2000CodingStyle *codsty = &s->codsty; Jpeg2000QuantStyle *qntsty = &s->qntsty; av_log(s->avctx, AV_LOG_DEBUG, "tier2\n"); // lay-rlevel-comp-pos progression for (reslevelno = 0; reslevelno < codsty->nr... |
1 | static void allwinner_ahci_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); dc->vmsd = &vmstate_allwinner_ahci;} |
1 | static QemuOpts *opts_parse(QemuOptsList *list, const char *params, int permit_abbrev, bool defaults){ const char *firstname; char value[1024], *id = NULL; const char *p; QemuOpts *opts; assert(!permit_abbrev || list->implied_opt_name); firstname = permit_abbrev ? list->implied_opt_name : NULL; if (strncmp(params, "id=... |
1 | static void chomp3(ChannelData *ctx, int16_t *output, uint8_t val, const uint16_t tab1[], const int16_t *tab2, int tab2_stride, uint32_t numChannels){ int16_t current; current = tab2[((ctx->index & 0x7f0) >> 4)*tab2_stride + val]; current = mace_broken_clip_int16(current + ctx->lev); ctx->lev = current - (current >> 3)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.