label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void virtio_net_tx_bh(void *opaque){ VirtIONetQueue *q = opaque; VirtIONet *n = q->n; VirtIODevice *vdev = VIRTIO_DEVICE(n); int32_t ret; assert(vdev->vm_running); q->tx_waiting = 0; /* Just in case the driver is not ready on more */ if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) { return; } ret = vi... |
0 | static int sclp_parse(const char *devname){ QemuOptsList *device = qemu_find_opts("device"); static int index = 0; char label[32]; QemuOpts *dev_opts; if (strcmp(devname, "none") == 0) { return 0; } if (index == MAX_SCLP_CONSOLES) { fprintf(stderr, "qemu: too many sclp consoles\n"); exit(1); } assert(arch_type == QEMU_... |
0 | void arm_gen_test_cc(int cc, int label){ TCGv_i32 tmp; int inv; switch (cc) { case 0: /* eq: Z */ tcg_gen_brcondi_i32(TCG_COND_EQ, cpu_ZF, 0, label); break; case 1: /* ne: !Z */ tcg_gen_brcondi_i32(TCG_COND_NE, cpu_ZF, 0, label); break; case 2: /* cs: C */ tcg_gen_brcondi_i32(TCG_COND_NE, cpu_CF, 0, label); break; case... |
0 | void ide_init_drive(IDEState *s, DriveInfo *dinfo, const char *version){ int cylinders, heads, secs; uint64_t nb_sectors; if (dinfo && dinfo->bdrv) { s->bs = dinfo->bdrv; bdrv_get_geometry(s->bs, &nb_sectors); bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs); s->cylinders = cylinders; s->heads = heads; s->sectors ... |
0 | static void ppc_heathrow_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; const char *kernel_cmdline = args->kernel_cmdline; const char *initrd_filename = args->initrd_filename; const char *boot_device = ... |
0 | static void synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max){ int sb, j, k, n, ch, run, channels; int joined_stereo, zero_encoding, chs; int type34_first; float type34_div = 0; float type34_predictor; float samples[10], sign_bits[16]; if (length == 0) { // If no data use... |
0 | void usb_desc_create_serial(USBDevice *dev){ DeviceState *hcd = dev->qdev.parent_bus->parent; const USBDesc *desc = usb_device_get_usb_desc(dev); int index = desc->id.iSerialNumber; char serial[64]; char *path; int dst; if (dev->serial) { /* 'serial' usb bus property has priority if present */ usb_desc_set_string(dev, ... |
0 | static void xics_kvm_cpu_setup(XICSState *xics, PowerPCCPU *cpu){ CPUState *cs; ICPState *ss; KVMXICSState *xicskvm = XICS_SPAPR_KVM(xics); cs = CPU(cpu); ss = &xics->ss[cs->cpu_index]; assert(cs->cpu_index < xics->nr_servers); if (xicskvm->kernel_xics_fd == -1) { abort(); } /* * If we are reusing a parked vCPU fd corr... |
0 | static inline void tcg_out_ldst(TCGContext *s, int ret, int addr, int offset, int op){ if (check_fit_tl(offset, 13)) { tcg_out32(s, op | INSN_RD(ret) | INSN_RS1(addr) | INSN_IMM13(offset)); } else { tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_T1, offset); tcg_out_ldst_rr(s, ret, addr, TCG_REG_T1, op); }} |
0 | void smbios_entry_add(QemuOpts *opts){ Error *local_err = NULL; const char *val; assert(!smbios_immutable); val = qemu_opt_get(opts, "file"); if (val) { struct smbios_structure_header *header; struct smbios_table *table; int size; qemu_opts_validate(opts, qemu_smbios_file_opts, &local_err); if (local_err) { error_repor... |
0 | static void guest_fsfreeze_cleanup(void){ int64_t ret; Error *err = NULL; if (guest_fsfreeze_state.status == GUEST_FSFREEZE_STATUS_FROZEN) { ret = qmp_guest_fsfreeze_thaw(&err); if (ret < 0 || err) { slog("failed to clean up frozen filesystems"); } }} |
0 | static int qesd_init_in (HWVoiceIn *hw, audsettings_t *as){ ESDVoiceIn *esd = (ESDVoiceIn *) hw; audsettings_t obt_as = *as; int esdfmt = ESD_STREAM | ESD_RECORD; int err; sigset_t set, old_set; sigfillset (&set); esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO; switch (as->fmt) { case AUD_FMT_S8: case AUD_FMT_U... |
0 | static int latm_write_packet(AVFormatContext *s, AVPacket *pkt){ LATMContext *ctx = s->priv_data; AVIOContext *pb = s->pb; PutBitContext bs; int i, len; uint8_t loas_header[] = "\x56\xe0\x00"; if (s->streams[0]->codecpar->codec_id == AV_CODEC_ID_AAC_LATM) return ff_raw_write_packet(s, pkt); if (!s->streams[0]->codecpar... |
0 | static void end_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv, ebml_master master){ uint8_t *buf, crc[4]; int size; if (pb->seekable) { size = avio_close_dyn_buf(*dyn_cp, &buf); if (mkv->write_crc && mkv->mode != MODE_WEBM) { AV_WL32(crc, av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), UI... |
0 | void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl){ H264Ref *const ref1 = &sl->ref_list[1][0]; H264Picture *const cur = h->cur_pic_ptr; int list, j, field; int sidx = (h->picture_structure & 1) ^ 1; int ref1sidx = (ref1->reference & 1) ^ 1; for (list = 0; list < sl->list_count; list++) ... |
0 | static av_cold int xvid_encode_init(AVCodecContext *avctx){ int xerr, i; int xvid_flags = avctx->flags; struct xvid_context *x = avctx->priv_data; uint16_t *intra, *inter; int fd; xvid_plugin_single_t single = { 0 }; struct xvid_ff_pass1 rc2pass1 = { 0 }; xvid_plugin_2pass2_t rc2pass2 = { 0 }; xvid_plugin_lumimasking_t... |
0 | static inline void RENAME(yuv2packedX)(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, long dstW, long dstY){#if COMPILE_TEMPLATE_MMX x86_reg dummy=0; x86_reg dstW_reg = dstW; ... |
1 | static inline int media_present(IDEState *s){ return (s->nb_sectors > 0);} |
1 | static void do_audio_out(AVFormatContext *s, AVOutputStream *ost, AVInputStream *ist, unsigned char *buf, int size){ uint8_t *buftmp; static uint8_t *audio_buf = NULL; static uint8_t *audio_out = NULL; const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE; int size_out, frame_bytes, ret; AVCodecContext *enc= ost->st->codec... |
1 | int qemu_thread_is_self(QemuThread *thread){ QemuThread *this_thread = TlsGetValue(qemu_thread_tls_index); return this_thread->thread == thread->thread;} |
1 | static void tcx_realizefn(DeviceState *dev, Error **errp){ SysBusDevice *sbd = SYS_BUS_DEVICE(dev); TCXState *s = TCX(dev); ram_addr_t vram_offset = 0; int size, ret; uint8_t *vram_base; char *fcode_filename; memory_region_init_ram(&s->vram_mem, OBJECT(s), "tcx.vram", s->vram_size * (1 + 4 + 4), &error_abort); vmstate_... |
1 | static int mace3_decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){ int16_t *samples = data; MACEContext *ctx = avctx->priv_data; int i, j, k; for(i = 0; i < avctx->channels; i++) { int16_t *output = samples + i; for (j=0; j < buf_size / 2 / avctx->channels; j++) for (k=0... |
1 | static void query_facilities(void){ struct sigaction sa_old, sa_new; register int r0 __asm__("0"); register void *r1 __asm__("1"); int fail; memset(&sa_new, 0, sizeof(sa_new)); sa_new.sa_handler = sigill_handler; sigaction(SIGILL, &sa_new, &sa_old); /* First, try STORE FACILITY LIST EXTENDED. If this is present, then w... |
1 | static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap){ NUTContext *nut = s->priv_data; ByteIOContext *bc = &s->pb; int64_t pos; int inited_stream_count; nut->avf= s; /* main header */ pos=0; for(;;){ pos= find_startcode(bc, MAIN_STARTCODE, pos)+1; if (pos<0){ av_log(s, AV_LOG_ERROR, "no main startcode ... |
0 | int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){ int ret, flush = 0; ret = check_packet(s, pkt); if (ret < 0) goto fail; if (pkt) { AVStream *st = s->streams[pkt->stream_index]; //FIXME/XXX/HACK drop zero sized packets if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size == 0) { ret = 0; goto ... |
0 | static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h, H264SliceContext *sl){ const int mb_x = h->mb_x; const int mb_y = h->mb_y; const int mb_xy = h->mb_xy; const int mb_type = h->cur_pic.mb_type[mb_xy]; uint8_t *dest[3]; int linesize; int i, j, p; int *block_offset = &h->block_offset[0]; const int transform_b... |
0 | static int synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max){ int sb, j, k, n, ch, run, channels; int joined_stereo, zero_encoding; int type34_first; float type34_div = 0; float type34_predictor; float samples[10]; int sign_bits[16]; if (length == 0) { // If no data use n... |
1 | static IsoBcSection *find_iso_bc_entry(void){ IsoBcEntry *e = (IsoBcEntry *)sec; uint32_t offset = find_iso_bc(); int i; if (!offset) { return NULL; } read_iso_sector(offset, sec, "Failed to read El Torito boot catalog"); if (!is_iso_bc_valid(e)) { /* The validation entry is mandatory */ virtio_panic("No valid boot cat... |
1 | static int ogg_new_stream(AVFormatContext *s, uint32_t serial, int new_avstream){ struct ogg *ogg = s->priv_data; int idx = ogg->nstreams++; AVStream *st; struct ogg_stream *os; ogg->streams = av_realloc (ogg->streams, ogg->nstreams * sizeof (*ogg->streams)); memset (ogg->streams + idx, 0, sizeof (*ogg->streams)); os =... |
1 | void gdb_exit(CPUArchState *env, int code){ GDBState *s; char buf[4]; s = gdbserver_state; if (!s) { return; }#ifdef CONFIG_USER_ONLY if (gdbserver_fd < 0 || s->fd < 0) { return; }#endif snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code); put_packet(s, buf);#ifndef CONFIG_USER_ONLY if (s->chr) { qemu_chr_delete(s->chr)... |
1 | SCSIRequest *scsi_req_alloc(size_t size, SCSIDevice *d, uint32_t tag, uint32_t lun){ SCSIRequest *req; req = qemu_mallocz(size); /* Two references: one is passed back to the HBA, one is in d->requests. */ req->refcount = 2; req->bus = scsi_bus_from_device(d); req->dev = d; req->tag = tag; req->lun = lun; req->status = ... |
1 | static void detach(sPAPRDRConnector *drc, DeviceState *d, spapr_drc_detach_cb *detach_cb, void *detach_cb_opaque, Error **errp){ DPRINTFN("drc: %x, detach", get_index(drc)); drc->detach_cb = detach_cb; drc->detach_cb_opaque = detach_cb_opaque; /* if we've signalled device presence to the guest, or if the guest * has go... |
1 | void xen_invalidate_map_cache_entry(uint8_t *buffer){ MapCacheEntry *entry = NULL, *pentry = NULL; MapCacheRev *reventry; target_phys_addr_t paddr_index; target_phys_addr_t size; int found = 0; if (mapcache->last_address_vaddr == buffer) { mapcache->last_address_index = -1; } QTAILQ_FOREACH(reventry, &mapcache->locked_... |
1 | static void adx_decode_stereo(short *out,const unsigned char *in,PREV *prev){short tmp[32*2];int i;adx_decode(tmp ,in ,prev);adx_decode(tmp+32,in+18,prev+1);for(i=0;i<32;i++) {out[i*2] = tmp[i];out[i*2+1] = tmp[i+32];}} |
1 | void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque){ SaveStateEntry *se, *new_se; char id[256] = ""; if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) { char *path = dev->parent_bus->info->get_dev_path(dev); if (path) { pstrcpy(id, sizeof(id), path); pstrcat(id, sizeof(id), "/"); ... |
1 | static void fsl_imx25_realize(DeviceState *dev, Error **errp){ FslIMX25State *s = FSL_IMX25(dev); uint8_t i; Error *err = NULL; object_property_set_bool(OBJECT(&s->cpu), true, "realized", &err); if (err) { error_propagate(errp, err); return; } object_property_set_bool(OBJECT(&s->avic), true, "realized", &err); if (err)... |
1 | int add_av_stream(FFStream *feed, AVStream *st){ AVStream *fst; AVCodecContext *av, *av1; int i; av = &st->codec; for(i=0;i<feed->nb_streams;i++) { st = feed->streams[i]; av1 = &st->codec; if (av1->codec_id == av->codec_id && av1->codec_type == av->codec_type && av1->bit_rate == av->bit_rate) { switch(av->codec_type) {... |
0 | static void mov_text_new_line_cb(void *priv, int forced){ MovTextContext *s = priv; av_strlcpy(s->ptr, "\n", FFMIN(s->end - s->ptr, 2)); s->ptr++;} |
0 | static void pulse_get_output_timestamp(AVFormatContext *h, int stream, int64_t *dts, int64_t *wall){ PulseData *s = h->priv_data; pa_usec_t latency; int neg; pa_threaded_mainloop_lock(s->mainloop); pa_stream_get_latency(s->stream, &latency, &neg); pa_threaded_mainloop_unlock(s->mainloop); *wall = av_gettime(); *dts = s... |
0 | static int update_packetheader(NUTContext *nut, ByteIOContext *bc, int additional_size){ int64_t start= nut->packet_start; int64_t cur= url_ftell(bc); int size= cur - start + additional_size; if(size != nut->written_packet_size){ int i; assert( size <= nut->written_packet_size ); url_fseek(bc, nut->packet_size_pos, SEE... |
0 | static int build_huff(const uint8_t *src, VLC *vlc){ int i; HuffEntry he[256]; int last; uint32_t codes[256]; uint8_t bits[256]; uint8_t syms[256]; uint32_t code; for (i = 0; i < 256; i++) { he[i].sym = i; he[i].len = *src++; } qsort(he, 256, sizeof(*he), huff_cmp); if (!he[0].len || he[0].len > 32) return -1; last = 2... |
1 | static void qemu_thread_set_name(QemuThread *thread, const char *name){#ifdef CONFIG_PTHREAD_SETNAME_NP pthread_setname_np(thread->thread, name);#endif} |
1 | int ff_jpeg2000_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy, AVCodecContext *avctx){ uint8_t log2_band_prec_width, log2_band_prec_height; int reslevelno, bandno, gbandno = 0, ret, i, j; uint32_t csize = 1; if (!codsty->nreslevels2decode) { av... |
1 | static void icp_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); dc->vmsd = &vmstate_icp_server; dc->realize = icp_realize;} |
1 | static void balloon_stats_poll_cb(void *opaque){ VirtIOBalloon *s = opaque; VirtIODevice *vdev = VIRTIO_DEVICE(s); if (!balloon_stats_supported(s)) { /* re-schedule */ balloon_stats_change_timer(s, s->stats_poll_interval); return; } virtqueue_push(s->svq, s->stats_vq_elem, s->stats_vq_offset); virtio_notify(vdev, s->sv... |
1 | void virtio_setup_block(struct subchannel_id schid){ struct vq_info_block info; struct vq_config_block config = {}; blk_cfg.blk_size = 0; /* mark "illegal" - setup started... */ guessed_disk_nature = false; virtio_reset(schid); /* * Skipping CCW_CMD_READ_FEAT. We're not doing anything fancy, and * we'll just stop dead ... |
1 | static void test_tco1_control_bits(void){ TestData d; uint16_t val; d.args = NULL; d.noreboot = true; test_init(&d); val = TCO_LOCK; qpci_io_writew(d.dev, d.tco_io_base + TCO1_CNT, val); val &= ~TCO_LOCK; qpci_io_writew(d.dev, d.tco_io_base + TCO1_CNT, val); g_assert_cmpint(qpci_io_readw(d.dev, d.tco_io_base + TCO1_CNT... |
1 | static void update_pam(PCII440FXState *d, uint32_t start, uint32_t end, int r, PAMMemoryRegion *mem){ if (mem->initialized) { memory_region_del_subregion(d->system_memory, &mem->mem); memory_region_destroy(&mem->mem); } // printf("ISA mapping %08x-0x%08x: %d\n", start, end, r); switch(r) { case 3: /* RAM */ memory_regi... |
0 | static int copy_cell(Indeo3DecodeContext *ctx, Plane *plane, Cell *cell){ int h, w, mv_x, mv_y, offset, offset_dst; uint8_t *src, *dst; /* setup output and reference pointers */ offset_dst = (cell->ypos << 2) * plane->pitch + (cell->xpos << 2); dst = plane->pixels[ctx->buf_sel] + offset_dst; mv_y = cell->mv_ptr[0]; mv_... |
0 | int av_expr_parse(AVExpr **expr, const char *s, const char * const *const_names, const char * const *func1_names, double (* const *funcs1)(void *, double), const char * const *func2_names, double (* const *funcs2)(void *, double, double), int log_offset, void *log_ctx){ Parser p; AVExpr *e = NULL; char *w = av_malloc(s... |
0 | static int disas_vfp_insn(DisasContext *s, uint32_t insn){ uint32_t rd, rn, rm, op, i, n, offset, delta_d, delta_m, bank_mask; int dp, veclen; TCGv_i32 addr; TCGv_i32 tmp; TCGv_i32 tmp2; if (!arm_dc_feature(s, ARM_FEATURE_VFP)) { return 1; } /* FIXME: this access check should not take precedence over UNDEF * for invali... |
0 | uint32_t cpu_mips_get_random (CPUMIPSState *env){ static uint32_t seed = 1; static uint32_t prev_idx = 0; uint32_t idx; /* Don't return same value twice, so get another value */ do { /* Use a simple algorithm of Linear Congruential Generator * from ISO/IEC 9899 standard. */ seed = 1103515245 * seed + 12345; idx = (seed... |
0 | void ppc_hash64_store_hpte(PowerPCCPU *cpu, target_ulong pte_index, target_ulong pte0, target_ulong pte1){ CPUPPCState *env = &cpu->env; if (env->external_htab == MMU_HASH64_KVM_MANAGED_HPT) { kvmppc_hash64_write_pte(env, pte_index, pte0, pte1); return; } pte_index *= HASH_PTE_SIZE_64; if (env->external_htab) { stq_p(e... |
0 | static uint64_t softusb_read(void *opaque, target_phys_addr_t addr, unsigned size){ MilkymistSoftUsbState *s = opaque; uint32_t r = 0; addr >>= 2; switch (addr) { case R_CTRL: r = s->regs[addr]; break; default: error_report("milkymist_softusb: read access to unknown register 0x" TARGET_FMT_plx, addr << 2); break; } tra... |
0 | GuestExec *qmp_guest_exec(const char *path, bool has_arg, strList *arg, bool has_env, strList *env, bool has_input_data, const char *input_data, bool has_capture_output, bool capture_output, Error **err){ GPid pid; GuestExec *ge = NULL; GuestExecInfo *gei; char **argv, **envp; strList arglist; gboolean ret; GError *ger... |
0 | static uint32_t cuda_readb(void *opaque, target_phys_addr_t addr){ CUDAState *s = opaque; uint32_t val; addr = (addr >> 9) & 0xf; switch(addr) { case 0: val = s->b; break; case 1: val = s->a; break; case 2: val = s->dirb; break; case 3: val = s->dira; break; case 4: val = get_counter(&s->timers[0]) & 0xff; s->ifr &= ~T... |
0 | assigned_dev_msix_mmio_read(void *opaque, target_phys_addr_t addr, unsigned size){ AssignedDevice *adev = opaque; uint64_t val; memcpy(&val, (void *)((uint8_t *)adev->msix_table + addr), size); return val;} |
0 | void ff_jpegls_init_state(JLSState *state){ int i; state->twonear = state->near * 2 + 1; state->range = ((state->maxval + state->twonear - 1) / state->twonear) + 1; // QBPP = ceil(log2(RANGE)) for(state->qbpp = 0; (1 << state->qbpp) < state->range; state->qbpp++); if(state->bpp < 8) state->limit = 16 + 2 * state->bpp -... |
0 | static int rtl8139_can_receive(void *opaque){ RTL8139State *s = opaque; int avail; /* Receive (drop) packets if card is disabled. */ if (!s->clock_enabled) return 1; if (!rtl8139_receiver_enabled(s)) return 1; if (rtl8139_cp_receiver_enabled(s)) { /* ??? Flow control not implemented in c+ mode. This is a hack to work a... |
0 | TC6393xbState *tc6393xb_init(MemoryRegion *sysmem, uint32_t base, qemu_irq irq){ TC6393xbState *s; DriveInfo *nand; static const MemoryRegionOps tc6393xb_ops = { .read = tc6393xb_readb, .write = tc6393xb_writeb, .endianness = DEVICE_NATIVE_ENDIAN, .impl = { .min_access_size = 1, .max_access_size = 1, }, }; s = (TC6393x... |
0 | int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov){ trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors); return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, BDRV_REQ_COPY_ON_READ);} |
0 | static void v9fs_lcreate(void *opaque){ int32_t dfid, flags, mode; gid_t gid; ssize_t err = 0; ssize_t offset = 7; V9fsString name; V9fsFidState *fidp; struct stat stbuf; V9fsQID qid; int32_t iounit; V9fsPDU *pdu = opaque; pdu_unmarshal(pdu, offset, "dsddd", &dfid, &name, &flags, &mode, &gid); trace_v9fs_lcreate(pdu->t... |
0 | void s390_virtio_irq(S390CPU *cpu, int config_change, uint64_t token){ if (kvm_enabled()) { kvm_s390_virtio_irq(cpu, config_change, token); } else { cpu_inject_ext(cpu, EXT_VIRTIO, config_change, token); }} |
0 | static int aiocb_needs_copy(struct qemu_paiocb *aiocb){ if (aiocb->aio_flags & QEMU_AIO_SECTOR_ALIGNED) { int i; for (i = 0; i < aiocb->aio_niov; i++) if ((uintptr_t) aiocb->aio_iov[i].iov_base % 512) return 1; } return 0;} |
0 | static void virtio_net_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); k->init = virtio_net_init_pci; k->exit = virtio_net_exit_pci; k->romfile = "pxe-virtio.rom"; k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; k->device_id = PCI_DEVICE_ID_V... |
0 | static int jpg_decode_data(JPGContext *c, int width, int height, const uint8_t *src, int src_size, uint8_t *dst, int dst_stride, const uint8_t *mask, int mask_stride, int num_mbs, int swapuv){ GetBitContext gb; int mb_w, mb_h, mb_x, mb_y, i, j; int bx, by; int unesc_size; int ret; if ((ret = av_reallocp(&c->buf, src_si... |
0 | static inline void upmix_mono_to_stereo(AC3DecodeContext *ctx){ int i; float (*output)[256] = ctx->audio_block.block_output; for (i = 0; i < 256; i++) output[2][i] = output[1][i];} |
0 | static void gen_flt3_arith (DisasContext *ctx, uint32_t opc, int fd, int fr, int fs, int ft){ const char *opn = "flt3_arith"; /* All of those work only on 64bit FPUs. */ gen_op_cp1_64bitmode(); switch (opc) { case OPC_ALNV_PS: GEN_LOAD_REG_TN(T0, fr); GEN_LOAD_FREG_FTN(DT0, fs); GEN_LOAD_FREG_FTN(DT1, ft); gen_op_float... |
0 | static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf){ return s->ops->lstat(&s->ctx, path->data, stbuf);} |
0 | static void test_source_timer_schedule(void){ TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL, .max = 2, .clock_type = QEMU_CLOCK_VIRTUAL }; int pipefd[2]; int64_t expiry; /* aio_poll will not block to wait for timers to complete unless it has * an fd to wait on. Fixing this breaks other tests. So cre... |
0 | static void xenfv_machine_options(MachineClass *m){ pc_common_machine_options(m); m->desc = "Xen Fully-virtualized PC"; m->max_cpus = HVM_MAX_VCPUS; m->default_machine_opts = "accel=xen"; m->hot_add_cpu = pc_hot_add_cpu;} |
0 | static CharDriverState *qemu_chr_open_socket(QemuOpts *opts){ CharDriverState *chr = NULL; TCPCharDriver *s = NULL; int fd = -1; int is_listen; int is_waitconnect; int do_nodelay; int is_unix; int is_telnet; is_listen = qemu_opt_get_bool(opts, "server", 0); is_waitconnect = qemu_opt_get_bool(opts, "wait", 1); is_telnet... |
0 | static void vfio_enable_intx_kvm(VFIODevice *vdev){#ifdef CONFIG_KVM struct kvm_irqfd irqfd = { .fd = event_notifier_get_fd(&vdev->intx.interrupt), .gsi = vdev->intx.route.irq, .flags = KVM_IRQFD_FLAG_RESAMPLE, }; struct vfio_irq_set *irq_set; int ret, argsz; int32_t *pfd; if (!kvm_irqfds_enabled() || vdev->intx.route.... |
0 | static inline void tcg_out_rld(TCGContext *s, int op, TCGReg ra, TCGReg rs, int sh, int mb){ assert(TCG_TARGET_REG_BITS == 64); sh = SH(sh & 0x1f) | (((sh >> 5) & 1) << 1); mb = MB64((mb >> 5) | ((mb << 1) & 0x3f)); tcg_out32(s, op | RA(ra) | RS(rs) | sh | mb);} |
0 | static int opt_list(void *obj, void *av_log_obj, char *unit){ AVOption *opt=NULL; while((opt= av_next_option(obj, opt))){ if(!(opt->flags & (AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM))) continue; /* Don't print CONST's on level one. * Don't print anything but CONST's on level two. * Only print items from th... |
0 | static int set_dirty_tracking(void){ BlkMigDevState *bmds; int ret; QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { bmds->dirty_bitmap = bdrv_create_dirty_bitmap(bmds->bs, BLOCK_SIZE, NULL); if (!bmds->dirty_bitmap) { ret = -errno; goto fail; } } return 0;fail: QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_l... |
0 | static void cmd_prevent_allow_medium_removal(IDEState *s, uint8_t* buf){ s->tray_locked = buf[4] & 1; bdrv_lock_medium(s->bs, buf[4] & 1); ide_atapi_cmd_ok(s);} |
0 | void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size){ int l; while (size > 0) { l = IO_BUF_SIZE - f->buf_index; if (l > size) l = size; memcpy(f->buf + f->buf_index, buf, l); f->buf_index += l; buf += l; size -= l; if (f->buf_index >= IO_BUF_SIZE) qemu_fflush(f); }} |
0 | void cpu_exec_init_all(void){#if !defined(CONFIG_USER_ONLY) qemu_mutex_init(&ram_list.mutex); memory_map_init(); io_mem_init();#endif} |
0 | static void create_fw_cfg(const VirtBoardInfo *vbi, AddressSpace *as){ hwaddr base = vbi->memmap[VIRT_FW_CFG].base; hwaddr size = vbi->memmap[VIRT_FW_CFG].size; char *nodename; fw_cfg_init_mem_wide(base + 8, base, 8, base + 16, as); nodename = g_strdup_printf("/fw-cfg@%" PRIx64, base); qemu_fdt_add_subnode(vbi->fdt, no... |
0 | int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, int log_offset, void *log_ctx){ FileLogContext file_log_ctx = { &file_log_ctx_class, log_offset, log_ctx }; int err, fd = open(filename, O_RDONLY); struct stat st; av_unused void *ptr; off_t off_size; char errbuf[128]; *bufptr = NULL; if (fd < 0) { e... |
0 | static void tcg_out_brcond_i32(TCGContext *s, TCGCond cond, TCGReg arg1, int32_t arg2, int const_arg2, int label){ tcg_out_cmp(s, arg1, arg2, const_arg2); tcg_out_bpcc(s, tcg_cond_to_bcond[cond], BPCC_ICC | BPCC_PT, label); tcg_out_nop(s);} |
0 | static void test_flush(void){ AHCIQState *ahci; ahci = ahci_boot_and_enable(); ahci_test_flush(ahci); ahci_shutdown(ahci);} |
0 | static void xtensa_lx200_init(MachineState *machine){ static const LxBoardDesc lx200_board = { .flash_base = 0xf8000000, .flash_size = 0x01000000, .flash_sector_size = 0x20000, .sram_size = 0x2000000, }; lx_init(&lx200_board, machine);} |
0 | static inline TCGv *compute_ldst_addr(DisasContext *dc, TCGv *t){ unsigned int extimm = dc->tb_flags & IMM_FLAG; /* Should be set to one if r1 is used by loadstores. */ int stackprot = 0; /* All load/stores use ra. */ if (dc->ra == 1) { stackprot = 1; } /* Treat the common cases first. */ if (!dc->type_b) { /* If any o... |
0 | static void decode_32Bit_opc(CPUTriCoreState *env, DisasContext *ctx){ int op1; int32_t r1, r2, r3; int32_t address, const16; int8_t b, const4; int32_t bpos; TCGv temp, temp2, temp3; op1 = MASK_OP_MAJOR(ctx->opcode); /* handle JNZ.T opcode only being 6 bit long */ if (unlikely((op1 & 0x3f) == OPCM_32_BRN_JTT)) { op1 = ... |
0 | static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, intptr_t arg2){ uint8_t *old_code_ptr = s->code_ptr; if (type == TCG_TYPE_I32) { tcg_out_op_t(s, INDEX_op_ld_i32); tcg_out_r(s, ret); tcg_out_r(s, arg1); tcg_out32(s, arg2); } else { assert(type == TCG_TYPE_I64);#if TCG_TARGET_REG_BITS == 64 t... |
0 | static bool s390_cpu_has_work(CPUState *cs){ S390CPU *cpu = S390_CPU(cs); CPUS390XState *env = &cpu->env; return (cs->interrupt_request & CPU_INTERRUPT_HARD) && (env->psw.mask & PSW_MASK_EXT);} |
0 | static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender, const struct iovec *iov, int iovcnt, NetPacketSent *sent_cb){ VLANPacket *packet; size_t max_len = 0; int i; max_len = calc_iov_length(iov, iovcnt); packet = qemu_malloc(sizeof(VLANPacket) + max_len); packet->sender = sender; packet->sent_cb = sent_cb; pac... |
0 | static void sm501_palette_write(void *opaque,target_phys_addr_t addr, uint32_t value){ SM501State * s = (SM501State *)opaque; SM501_DPRINTF("sm501 palette write addr=%x, val=%x\n", (int)addr, value); /* TODO : consider BYTE/WORD access */ /* TODO : consider endian */ assert(0 <= addr && addr < 0x400 * 3); *(uint32_t*)&... |
0 | static int qemu_gluster_open(BlockDriverState *bs, QDict *options, int bdrv_flags, Error **errp){ BDRVGlusterState *s = bs->opaque; int open_flags = O_BINARY; int ret = 0; GlusterConf *gconf = g_malloc0(sizeof(GlusterConf)); QemuOpts *opts; Error *local_err = NULL; const char *filename; opts = qemu_opts_create(&runtime... |
0 | static int draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir){ AVFilterContext *ctx = inlink->dst; TileContext *tile = ctx->priv; AVFilterLink *outlink = ctx->outputs[0]; unsigned x0, y0; get_current_tile_pos(ctx, &x0, &y0); ff_copy_rectangle2(&tile->draw, outlink->out_buf->data, outlink->out_buf->linesize, ... |
0 | static int disas_vfp_insn(CPUState * env, DisasContext *s, uint32_t insn){ uint32_t rd, rn, rm, op, i, n, offset, delta_d, delta_m, bank_mask; int dp, veclen; TCGv addr; TCGv tmp; TCGv tmp2; if (!arm_feature(env, ARM_FEATURE_VFP)) return 1; if (!s->vfp_enabled) { /* VFP disabled. Only allow fmxr/fmrx to/from some contr... |
0 | void cpu_check_irqs(CPUState *env){ uint32_t pil = env->pil_in | (env->softint & ~SOFTINT_TIMER) | ((env->softint & SOFTINT_TIMER) << 14); if (pil && (env->interrupt_index == 0 || (env->interrupt_index & ~15) == TT_EXTINT)) { unsigned int i; for (i = 15; i > 0; i--) { if (pil & (1 << i)) { int old_interrupt = env->inte... |
0 | static int default_fdset_dup_fd_find(int dup_fd){ return -1;} |
0 | static void t_gen_muls(TCGv d, TCGv d2, TCGv a, TCGv b){TCGv t0, t1;t0 = tcg_temp_new(TCG_TYPE_I64);t1 = tcg_temp_new(TCG_TYPE_I64);tcg_gen_ext32s_i64(t0, a);tcg_gen_ext32s_i64(t1, b);tcg_gen_mul_i64(t0, t0, t1);tcg_gen_trunc_i64_i32(d, t0);tcg_gen_shri_i64(t0, t0, 32);tcg_gen_trunc_i64_i32(d2, t0);tcg_temp_free(t0);tc... |
0 | static void vnc_client_write(void *opaque){ long ret; VncState *vs = opaque;#ifdef CONFIG_VNC_TLS if (vs->tls_session) {ret = gnutls_write(vs->tls_session, vs->output.buffer, vs->output.offset);if (ret < 0) { if (ret == GNUTLS_E_AGAIN)errno = EAGAIN; elseerrno = EIO; ret = -1;} } else#endif /* CONFIG_VNC_TLS */ret = se... |
0 | static void test_drive_del_device_del(void){ /* Start with a drive used by a device that unplugs instantaneously */ qtest_start("-drive if=none,id=drive0,file=null-co://,format=raw" " -device virtio-scsi-pci" " -device scsi-hd,drive=drive0,id=dev0"); /* * Delete the drive, and then the device * Doing it in this order t... |
0 | static void omap_uwire_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ struct omap_uwire_s *s = (struct omap_uwire_s *) opaque; int offset = addr & OMAP_MPUI_REG_MASK; if (size != 2) { return omap_badwidth_write16(opaque, addr, value); } switch (offset) { case 0x00:/* TDR */ s->txbuf = valu... |
0 | static inline void _t_gen_mov_env_TN(int offset, TCGv tn){ if (offset > sizeof(CPUCRISState)) { fprintf(stderr, "wrong store to env at off=%d\n", offset); } tcg_gen_st_tl(tn, cpu_env, offset);} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.